@zeph-to/mcp-server 1.15.1 → 1.16.0

package/README.md

@@ -138,15 +138,21 @@ priority:  "normal"
 
 ### zeph_file
 
-Send a text file to the user's device.
+Send a file to the user's device. Either `filePath` (a file already on disk) or
+`content` (text you generated) is required.
 
 ```
-fileName:       "report.json"
-content:        "{\"status\": \"ok\"}"
-title:          "Build Report"  (optional, defaults to fileName)
-targetDeviceId: "dev_..."       (optional)
+filePath:       "/abs/path/screenshot.png"  (images, PDFs, logs — anything on disk)
+content:        "{\"status\": \"ok\"}"       (text only; requires fileName)
+fileName:       "report.json"               (required with content; defaults to basename of filePath)
+title:          "Build Report"              (optional, defaults to fileName)
+targetDeviceId: "dev_..."                   (optional)
 ```
 
+Images are delivered with their real mime type and render inline on the device.
+Never base64 a binary file into `content` — pass `filePath` and the server reads
+the bytes off disk.
+
 Returns: `{ pushId: "...", fileKey: "...", fileSize: 42 }`
 
 ### zeph_session_rename

package/dist/crypto.d.ts

@@ -54,6 +54,16 @@
 export declare const initCrypto: (apiKey?: string, baseUrl?: string) => Promise<string>;
 export declare const getKeyPair: () => CryptoKeyPair | null;
 export declare const getPublicKey: () => string | null;
+/**
+ * Drop the cached keys so every later send goes out as plaintext.
+ *
+ * Used when the server refuses an encrypted send with `PRO_REQUIRED`
+ * (ADR-0008): E2E is Pro-only, and this server initialized crypto once at
+ * startup — a downgrade after that is only visible at send time. Same end
+ * state as the `ZEPH_DISABLE_ENCRYPTION` opt-out. Keys on disk are untouched;
+ * a restart after an upgrade re-adopts them.
+ */
+export declare const disableCrypto: () => void;
 /**
  * Encrypt push body for self (all own devices).
  */
@@ -70,7 +80,7 @@ export declare const encryptPushBodyForSelf: (input: {
 /**
  * Encrypt file content for self (all own devices).
  */
-export declare const encryptFileForSelf: (content: string) => Promise<{
+export declare const encryptFileForSelf: (content: string | Buffer) => Promise<{
     ciphertext: Buffer;
     iv: string;
     encryptedKey: string;

package/dist/crypto.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"crypto.d.ts","sourceRoot":"","sources":["../src/crypto.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AA0JH;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,UAAU,GAAI,SAAS,MAAM,EAAE,UAAU,MAAM,KAAG,OAAO,CAAC,MAAM,CAsE5E,CAAC;AAmCF,eAAO,MAAM,UAAU,QAAO,aAAa,GAAG,IAAqB,CAAC;AACpE,eAAO,MAAM,YAAY,QAAO,MAAM,GAAG,IAA+B,CAAC;AAEzE;;GAEG;AACH,eAAO,MAAM,sBAAsB,GACjC,OAAO;IAAE,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAA;CAAE,KACrD,OAAO,CAAC;IACT,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,EAAE,MAAM,CAAC;IACrB,eAAe,EAAE,MAAM,CAAC;IACxB,WAAW,EAAE,IAAI,CAAC;CACnB,CAaA,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,kBAAkB,GAC7B,SAAS,MAAM,KACd,OAAO,CAAC;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,YAAY,EAAE,MAAM,CAAA;CAAE,CAQlE,CAAC"}
+{"version":3,"file":"crypto.d.ts","sourceRoot":"","sources":["../src/crypto.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAiKH;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,UAAU,GAAI,SAAS,MAAM,EAAE,UAAU,MAAM,KAAG,OAAO,CAAC,MAAM,CAsE5E,CAAC;AAmCF,eAAO,MAAM,UAAU,QAAO,aAAa,GAAG,IAAqB,CAAC;AACpE,eAAO,MAAM,YAAY,QAAO,MAAM,GAAG,IAA+B,CAAC;AAEzE;;;;;;;;GAQG;AACH,eAAO,MAAM,aAAa,QAAO,IAIhC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,sBAAsB,GACjC,OAAO;IAAE,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAA;CAAE,KACrD,OAAO,CAAC;IACT,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,EAAE,MAAM,CAAC;IACrB,eAAe,EAAE,MAAM,CAAC;IACxB,WAAW,EAAE,IAAI,CAAC;CACnB,CAaA,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,kBAAkB,GAC7B,SAAS,MAAM,GAAG,MAAM,KACvB,OAAO,CAAC;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,YAAY,EAAE,MAAM,CAAA;CAAE,CAQlE,CAAC"}

package/dist/crypto.js

@@ -29,7 +29,7 @@
  *   sensitive-but-not-secret.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.encryptFileForSelf = exports.encryptPushBodyForSelf = exports.getPublicKey = exports.getKeyPair = exports.initCrypto = void 0;
+exports.encryptFileForSelf = exports.encryptPushBodyForSelf = exports.disableCrypto = exports.getPublicKey = exports.getKeyPair = exports.initCrypto = void 0;
 /// <reference lib="dom" />
 const fs_1 = require("fs");
 const os_1 = require("os");
@@ -78,7 +78,13 @@ const encrypt = async (plaintext, senderPrivateKey, recipientPublicKey) => {
 };
 // ─── File encryption ───
 const encryptFileContent = async (content, senderPrivateKey, recipientPublicKey) => {
-    const buffer = new TextEncoder().encode(content).buffer;
+    // Binary attachments arrive as a Buffer and must be encrypted byte for byte —
+    // running them through TextEncoder would UTF-8 mangle every non-ASCII byte.
+    // Both branches are views; subtle.encrypt honours byteOffset/byteLength, so a
+    // Buffer carved out of Node's pool encrypts only its own bytes.
+    const buffer = typeof content === 'string'
+        ? new TextEncoder().encode(content)
+        : new Uint8Array(content.buffer, content.byteOffset, content.byteLength);
     const fileKey = await crypto.subtle.generateKey({ name: 'AES-GCM', length: 256 }, true, ['encrypt', 'decrypt']);
     const iv = crypto.getRandomValues(new Uint8Array(12));
     const ciphertext = await crypto.subtle.encrypt({ name: 'AES-GCM', iv }, fileKey, buffer);
@@ -241,6 +247,21 @@ const getKeyPair = () => cachedKeyPair;
 exports.getKeyPair = getKeyPair;
 const getPublicKey = () => cachedExportedPublicKey;
 exports.getPublicKey = getPublicKey;
+/**
+ * Drop the cached keys so every later send goes out as plaintext.
+ *
+ * Used when the server refuses an encrypted send with `PRO_REQUIRED`
+ * (ADR-0008): E2E is Pro-only, and this server initialized crypto once at
+ * startup — a downgrade after that is only visible at send time. Same end
+ * state as the `ZEPH_DISABLE_ENCRYPTION` opt-out. Keys on disk are untouched;
+ * a restart after an upgrade re-adopts them.
+ */
+const disableCrypto = () => {
+    cachedKeyPair = null;
+    cachedExportedPublicKey = null;
+    cachedOwnPublicKey = null;
+};
+exports.disableCrypto = disableCrypto;
 /**
  * Encrypt push body for self (all own devices).
  */

package/dist/e2e-fallback.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Run a send, and repeat it unencrypted if the server says E2E needs Pro.
+ *
+ * E2E is Pro-only (ADR-0008) and `POST /pushes/send` rejects `isEncrypted`
+ * from a free account with 403 `PRO_REQUIRED`. Crypto initializes once at
+ * server startup, so a downgrade after that is only visible at send time — and
+ * a notification must not be lost over a billing state change. The keys are
+ * dropped before the retry, so later sends skip encryption outright and the
+ * retry rebuilds the whole payload (a file re-uploads as plaintext instead of
+ * leaving an undecryptable blob in S3).
+ *
+ * `send` receives whether it may encrypt, and must be safe to run twice — the
+ * encrypted first upload is left orphaned in S3, which is the accepted cost of
+ * not shipping an unreadable attachment. The retry is not itself retried: a
+ * second `PRO_REQUIRED` propagates.
+ */
+export declare const withPlaintextFallback: <T>(send: (canEncrypt: boolean) => Promise<T>) => Promise<T>;
+//# sourceMappingURL=e2e-fallback.d.ts.map

package/dist/e2e-fallback.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"e2e-fallback.d.ts","sourceRoot":"","sources":["../src/e2e-fallback.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,qBAAqB,GAAU,CAAC,EAC3C,MAAM,CAAC,UAAU,EAAE,OAAO,KAAK,OAAO,CAAC,CAAC,CAAC,KACxC,OAAO,CAAC,CAAC,CAYX,CAAC"}

package/dist/e2e-fallback.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withPlaintextFallback = void 0;
+const api_client_js_1 = require("./api-client.js");
+const crypto_js_1 = require("./crypto.js");
+/**
+ * Run a send, and repeat it unencrypted if the server says E2E needs Pro.
+ *
+ * E2E is Pro-only (ADR-0008) and `POST /pushes/send` rejects `isEncrypted`
+ * from a free account with 403 `PRO_REQUIRED`. Crypto initializes once at
+ * server startup, so a downgrade after that is only visible at send time — and
+ * a notification must not be lost over a billing state change. The keys are
+ * dropped before the retry, so later sends skip encryption outright and the
+ * retry rebuilds the whole payload (a file re-uploads as plaintext instead of
+ * leaving an undecryptable blob in S3).
+ *
+ * `send` receives whether it may encrypt, and must be safe to run twice — the
+ * encrypted first upload is left orphaned in S3, which is the accepted cost of
+ * not shipping an unreadable attachment. The retry is not itself retried: a
+ * second `PRO_REQUIRED` propagates.
+ */
+const withPlaintextFallback = async (send) => {
+    const canEncrypt = !!(0, crypto_js_1.getKeyPair)() && !!(0, crypto_js_1.getPublicKey)();
+    if (!canEncrypt)
+        return send(false);
+    try {
+        return await send(true);
+    }
+    catch (err) {
+        if (!(err instanceof api_client_js_1.ApiError) || err.code !== 'PRO_REQUIRED')
+            throw err;
+        (0, crypto_js_1.disableCrypto)();
+        console.error('[Crypto] End-to-end encryption requires Zeph Pro — resending as plaintext.');
+        return send(false);
+    }
+};
+exports.withPlaintextFallback = withPlaintextFallback;

package/dist/index.js

@@ -49,7 +49,7 @@ const createServer = (config) => {
             '- zeph_dismiss: Mark a push as read',
             '- zeph_dismiss_all: Clear all notifications',
             '- zeph_broadcast: Send to all subscribers of a channel',
-            '- zeph_file: Send a text file (logs, reports, code)',
+            '- zeph_file: Send a file — pass filePath for anything on disk (images, PDFs, logs), or content for generated text',
             '- zeph_prompt: Ask user to choose from options (requires ZEPH_HOOK_ID)',
             '- zeph_input: Request text input from user (requires ZEPH_HOOK_ID)',
             '- zeph_ask: Ask user with buttons + text input combined (requires ZEPH_HOOK_ID). Prefer this over zeph_prompt/zeph_input when you need both options and free-text.',

package/dist/mime.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mime.d.ts","sourceRoot":"","sources":["../src/mime.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAkBH,eAAO,MAAM,aAAa,GAAI,UAAU,MAAM,KAAG,MAGhD,CAAC"}
+{"version":3,"file":"mime.d.ts","sourceRoot":"","sources":["../src/mime.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAsCH,eAAO,MAAM,aAAa,GAAI,UAAU,MAAM,KAAG,MAGhD,CAAC"}

package/dist/mime.js

@@ -22,6 +22,26 @@ const EXT_TO_MIME = {
     js: 'text/javascript',
     py: 'text/x-python',
     sh: 'text/x-shellscript',
+    // Keep this image set in sync with IMAGE_EXTENSIONS in the Zeph client
+    // (`libs/shared/src/utils/file.ts`) — an extension the client calls an image
+    // but this map doesn't will be labelled text/plain and decoded as UTF-8 on
+    // open, which corrupts it. Separate repos, so nothing enforces the match.
+    png: 'image/png',
+    jpg: 'image/jpeg',
+    jpeg: 'image/jpeg',
+    gif: 'image/gif',
+    webp: 'image/webp',
+    heic: 'image/heic',
+    heif: 'image/heif',
+    bmp: 'image/bmp',
+    avif: 'image/avif',
+    ico: 'image/x-icon',
+    tiff: 'image/tiff',
+    tif: 'image/tiff',
+    // No svg entry on purpose: an SVG is a script-bearing document, and the
+    // clients open decrypted attachments from a same-origin blob URL. It falls
+    // through to text/plain, which the text viewer handles fine.
+    pdf: 'application/pdf',
 };
 const inferMimeType = (fileName) => {
     const ext = fileName.split('.').pop()?.toLowerCase();

package/dist/tools/file.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"file.d.ts","sourceRoot":"","sources":["../../src/tools/file.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AACzE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACtD,OAAO,EAAmB,KAAK,eAAe,EAAE,MAAM,cAAc,CAAC;AAKrE,eAAO,MAAM,gBAAgB,GAAI,QAAQ,SAAS,EAAE,QAAQ,aAAa,EAAE,QAAQ,eAAe,SA2EjG,CAAC"}
+{"version":3,"file":"file.d.ts","sourceRoot":"","sources":["../../src/tools/file.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AACzE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACtD,OAAO,EAAmB,KAAK,eAAe,EAAE,MAAM,cAAc,CAAC;AA4BrE,eAAO,MAAM,gBAAgB,GAAI,QAAQ,SAAS,EAAE,QAAQ,aAAa,EAAE,QAAQ,eAAe,SAoHjG,CAAC"}

package/dist/tools/file.js

@@ -2,37 +2,95 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.registerFileTool = void 0;
 const zod_1 = require("zod");
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
 const config_js_1 = require("../config.js");
 const error_format_js_1 = require("../error-format.js");
 const crypto_js_1 = require("../crypto.js");
+const e2e_fallback_js_1 = require("../e2e-fallback.js");
 const mime_js_1 = require("../mime.js");
+/**
+ * Collapse the two accepted input shapes into one payload.
+ *
+ * A `filePath` stays a Buffer end to end — images and PDFs only survive the
+ * trip as raw bytes, and reading from disk keeps a several-hundred-KB
+ * attachment out of the tool call itself (base64 in the arguments would
+ * inflate it by a third and burn the agent's context).
+ */
+const resolvePayload = async (args) => {
+    if (args.filePath) {
+        const body = await (0, promises_1.readFile)(args.filePath);
+        return { fileName: args.fileName ?? (0, node_path_1.basename)(args.filePath), body, size: body.byteLength };
+    }
+    return {
+        fileName: args.fileName,
+        body: args.content,
+        size: new TextEncoder().encode(args.content).byteLength,
+    };
+};
 const registerFileTool = (server, client, config) => {
     server.registerTool('zeph_file', {
-        description: 'Send a text file to the user\'s device. The content is uploaded and delivered as a file push. Use for logs, reports, code snippets, or any text content.',
+        description: 'Send a file to the user\'s device. Pass `filePath` to send a file that already exists on disk — images (png/jpg/gif/webp/heic), PDFs, logs, anything. Pass `content` instead to send text you generated. Images render inline on the device.',
         annotations: {
             readOnlyHint: false,
             destructiveHint: false,
             openWorldHint: true,
         },
         inputSchema: {
-            fileName: zod_1.z.string().describe('File name with extension (e.g., "report.txt", "output.json")'),
-            content: zod_1.z.string().describe('Text content of the file'),
+            filePath: zod_1.z
+                .string()
+                .optional()
+                .describe('Absolute path to a local file to send. Required for images, PDFs, and any other binary — never base64 a file into `content`.'),
+            content: zod_1.z.string().optional().describe('Text content of the file. Use only for text you generated; requires `fileName`.'),
+            fileName: zod_1.z
+                .string()
+                .optional()
+                .describe('File name with extension (e.g., "report.txt"). Required with `content`; defaults to the basename of `filePath`.'),
             title: zod_1.z.string().optional().describe('Notification title (defaults to fileName)'),
             targetDeviceId: zod_1.z.string().optional().describe('Target device ID. Omit to use configured default or send to all devices.'),
         },
-    }, async ({ fileName, content, title, targetDeviceId }) => {
+    }, async ({ filePath, fileName: fileNameArg, content, title, targetDeviceId }) => {
+        if (!filePath && content === undefined) {
+            return (0, error_format_js_1.errorResult)({
+                error: 'INVALID_INPUT',
+                message: 'Either filePath or content is required',
+                suggestion: 'Pass filePath for a file on disk (images, PDFs), or content + fileName for generated text',
+            });
+        }
+        if (!filePath && !fileNameArg) {
+            return (0, error_format_js_1.errorResult)({
+                error: 'INVALID_INPUT',
+                message: 'fileName is required when sending content',
+                suggestion: 'Add fileName with an extension, e.g. "report.md"',
+            });
+        }
+        let payload;
         try {
-            const canEncrypt = !!(0, crypto_js_1.getKeyPair)() && !!(0, crypto_js_1.getPublicKey)();
+            // Resolved once, outside `send`, so the plaintext retry below doesn't
+            // read the file from disk a second time.
+            payload = await resolvePayload({ filePath, content, fileName: fileNameArg });
+        }
+        catch (err) {
+            return (0, error_format_js_1.errorResult)({
+                error: 'FILE_READ_FAILED',
+                message: err instanceof Error ? err.message : String(err),
+                suggestion: 'Check that filePath is an absolute path to a readable file',
+            });
+        }
+        const { fileName, body, size: originalSize } = payload;
+        // Runs a second time as plaintext if the server refuses E2E (Pro-only,
+        // ADR-0008). The retry re-uploads the file unencrypted, so the whole
+        // upload-then-send sequence has to sit inside this closure.
+        const send = async (canEncrypt) => {
             let fileType = (0, mime_js_1.inferMimeType)(fileName);
-            const originalSize = new TextEncoder().encode(content).byteLength;
             // Step 1: Optionally encrypt file content
-            let uploadContent = content;
+            let uploadContent = body;
             let uploadSize = originalSize;
             let fileIv;
             let fileEncryptedKey;
             if (canEncrypt) {
                 try {
-                    const encrypted = await (0, crypto_js_1.encryptFileForSelf)(content);
+                    const encrypted = await (0, crypto_js_1.encryptFileForSelf)(body);
                     uploadContent = encrypted.ciphertext;
                     uploadSize = encrypted.ciphertext.length;
                     fileType = 'application/octet-stream';
@@ -67,6 +125,9 @@ const registerFileTool = (server, client, config) => {
             }
             const result = await client.sendPush(pushPayload);
             return (0, error_format_js_1.textResult)({ pushId: result.data.pushId, fileKey: upload.data.fileKey, fileSize: originalSize, encrypted: canEncrypt });
+        };
+        try {
+            return await (0, e2e_fallback_js_1.withPlaintextFallback)(send);
         }
         catch (err) {
             return (0, error_format_js_1.formatToolError)(err);

package/dist/tools/notify.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"notify.d.ts","sourceRoot":"","sources":["../../src/tools/notify.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AACzE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAEtD,OAAO,EAAmB,KAAK,eAAe,EAAE,MAAM,cAAc,CAAC;AASrE,eAAO,MAAM,kBAAkB,GAAI,QAAQ,SAAS,EAAE,QAAQ,aAAa,EAAE,QAAQ,eAAe,SA2HnG,CAAC"}
+{"version":3,"file":"notify.d.ts","sourceRoot":"","sources":["../../src/tools/notify.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AACzE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAEtD,OAAO,EAAmB,KAAK,eAAe,EAAE,MAAM,cAAc,CAAC;AAUrE,eAAO,MAAM,kBAAkB,GAAI,QAAQ,SAAS,EAAE,QAAQ,aAAa,EAAE,QAAQ,eAAe,SAgInG,CAAC"}

package/dist/tools/notify.js

@@ -5,6 +5,7 @@ const zod_1 = require("zod");
 const error_format_js_1 = require("../error-format.js");
 const config_js_1 = require("../config.js");
 const crypto_js_1 = require("../crypto.js");
+const e2e_fallback_js_1 = require("../e2e-fallback.js");
 const mime_js_1 = require("../mime.js");
 const sanitize_js_1 = require("../sanitize.js");
 // The device feed shows a short preview of the body. Anything longer gets
@@ -29,14 +30,15 @@ const registerNotifyTool = (server, client, config) => {
             targetDeviceId: zod_1.z.string().optional().describe('Target device ID. Omit to use configured default or send to all devices.'),
         },
     }, async ({ title, body, url, priority, targetDeviceId }) => {
-        try {
+        // Runs a second time as plaintext if the server refuses E2E (Pro-only,
+        // ADR-0008) — hence everything after the encryption decision lives here.
+        const send = async (canEncrypt) => {
             const deviceId = targetDeviceId ?? config.deviceId;
             const pushTitle = (0, config_js_1.formatPushTitle)(config.projectName, title);
             // Strip any tool-call markup that leaked into the body argument.
             const cleanBody = (0, sanitize_js_1.sanitizeText)(body);
             // Attach a file whenever the body would be clipped in the feed preview.
             const isLongBody = !!cleanBody && cleanBody.length > PREVIEW_LENGTH;
-            const canEncrypt = !!(0, crypto_js_1.getKeyPair)() && !!(0, crypto_js_1.getPublicKey)();
             if (isLongBody && cleanBody) {
                 const fileName = 'response.md';
                 const fileType = (0, mime_js_1.inferMimeType)(fileName);
@@ -115,6 +117,9 @@ const registerNotifyTool = (server, client, config) => {
             }
             const result = await client.sendPush(pushPayload);
             return (0, error_format_js_1.textResult)({ pushId: result.data.pushId, encrypted: pushEncrypted });
+        };
+        try {
+            return await (0, e2e_fallback_js_1.withPlaintextFallback)(send);
         }
         catch (err) {
             return (0, error_format_js_1.formatToolError)(err);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zeph-to/mcp-server",
-  "version": "1.15.1",
+  "version": "1.16.0",
   "description": "Zeph MCP server — AI agent notifications, prompts, and input via MCP protocol",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",