@heylemon/lemonade 2026.2.19 → 2026.2.21

package/dist/build-info.json

@@ -1,5 +1,5 @@
 {
-  "version": "2026.2.19",
-  "commit": "c777f36571f501d0553aacf38e22f45e00f135b2",
-  "builtAt": "2026-02-19T10:34:34.300Z"
+  "version": "2026.2.21",
+  "commit": "f1adf7fa5b1b100dc4f58d4325177d6e5b5b8a7d",
+  "builtAt": "2026-02-19T11:32:30.329Z"
 }

package/dist/canvas-host/a2ui/.bundle.hash

@@ -1 +1 @@
-65a14b12e4ff701a566b2ab1dd533ba4b4789395611a1e7af703c28197f10d78
+61cedf672a2f645b8bc0c25ed3098af955cc9ee4c0a98935bd816883b972f478

package/dist/media-understanding/runner.js

@@ -426,6 +426,12 @@ async function resolveAutoEntries(params) {
         return [keys];
     return [];
 }
+function isWhatsAppContext(ctx) {
+    const candidates = [ctx.Surface, ctx.Provider, ctx.OriginatingChannel]
+        .map((value) => value?.trim().toLowerCase())
+        .filter((value) => Boolean(value));
+    return candidates.some((value) => value === "whatsapp");
+}
 export async function resolveAutoImageModel(params) {
     const providerRegistry = buildProviderRegistry();
     const toActive = (entry) => {
@@ -1001,6 +1007,70 @@ export async function runCapability(params) {
             };
         }
     }
+    // For WhatsApp audio, force local Parakeet transcription only.
+    // Do not fall back to whisper/provider-based transcription paths.
+    if (capability === "audio" && isWhatsAppContext(ctx)) {
+        const parakeetEntry = await resolveLocalParakeetEntry();
+        if (!parakeetEntry) {
+            if (shouldLogVerbose()) {
+                logVerbose("audio understanding skipped for WhatsApp: local Parakeet is unavailable");
+            }
+            return {
+                outputs: [],
+                decision: {
+                    capability,
+                    outcome: "skipped",
+                    attachments: selected.map((item) => ({
+                        attachmentIndex: item.index,
+                        attempts: [
+                            {
+                                type: "cli",
+                                provider: "local-parakeet",
+                                model: "parakeet",
+                                outcome: "skipped",
+                                reason: "local Parakeet unavailable",
+                            },
+                        ],
+                        chosen: undefined,
+                    })),
+                },
+            };
+        }
+        const outputs = [];
+        const attachmentDecisions = [];
+        for (const attachment of selected) {
+            const { output, attempts } = await runAttachmentEntries({
+                capability,
+                cfg,
+                ctx,
+                attachmentIndex: attachment.index,
+                agentDir: params.agentDir,
+                providerRegistry: params.providerRegistry,
+                cache: params.attachments,
+                entries: [parakeetEntry],
+                config,
+            });
+            if (output)
+                outputs.push(output);
+            attachmentDecisions.push({
+                attachmentIndex: attachment.index,
+                attempts,
+                chosen: attempts.find((attempt) => attempt.outcome === "success"),
+            });
+        }
+        const decision = {
+            capability,
+            outcome: outputs.length > 0 ? "success" : "skipped",
+            attachments: attachmentDecisions,
+        };
+        if (shouldLogVerbose()) {
+            logVerbose(`Media understanding ${formatDecisionSummary(decision)} (forced local Parakeet)`);
+        }
+        return {
+            outputs,
+            decision,
+        };
+    }
     const entries = resolveModelEntries({
         cfg,
         capability,

package/dist/web/inbound/monitor.js

@@ -333,7 +333,9 @@ export async function monitorWebInbox(options) {
                     const maxBytes = maxMb * 1024 * 1024;
                     const saved = await saveMediaBuffer(inboundMedia.buffer, inboundMedia.mimetype, "inbound", maxBytes);
                     mediaPath = saved.path;
-                    mediaType = inboundMedia.mimetype;
+                    // Prefer detected mime from saved media (sniffed from bytes), then
+                    // fall back to transport-provided mimetype.
+                    mediaType = saved.contentType ?? inboundMedia.mimetype;
                     // Extract text from document attachments (PDF, DOCX, etc.)
                     if (mediaPath && isExtractableDocument(mediaType)) {
                         try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@heylemon/lemonade",
-  "version": "2026.2.19",
+  "version": "2026.2.21",
   "description": "AI gateway CLI for Lemon - local AI assistant with integrations",
   "publishConfig": {
     "access": "restricted"