wazap-mcp 0.9.6 → 0.9.7

package/README.md

@@ -180,8 +180,8 @@ manifest, the icon and a fresh production `node_modules`, then packs them with
 | `learn` | read | The guide to every tool, id format and error code. Call it first. |
 | `get_status` | read | Connection status, sync state, linked account, named-contact count, versions, data dir. |
 | `list_chats` | read | Conversations newest-first; filter `all`/`unread`/`groups`/`individual`/`archived`. |
-| `read_messages` | read | Messages in a chat; `before` pages further back, pulling older history from the phone. |
-| `get_recent_messages` | read | Everything from the last N hours, grouped by chat. The catch-up tool. `include_system` adds WhatsApp's own notices. |
+| `read_messages` | read | Messages in a chat; `before` pages further back, pulling older history from the phone; `types` narrows to one or more message types, e.g. `["call"]`. |
+| `get_recent_messages` | read | Everything from the last N hours, grouped by chat. The catch-up tool. `include_system` adds WhatsApp's own notices, `types` narrows to one or more message types. |
 | `search_messages` | read | Text search across the locally held messages. |
 | `get_message` | read | One message in full, with its quoted message and reactions. |
 | `search_contacts` | read | Find contacts by name or number. |
@@ -404,6 +404,12 @@ Flags beat environment variables, which beat `<data-dir>/.env`.
   state sync, and only to a connection asking for it from scratch. If contacts
   read as phone numbers and `get_status` shows `contacts_named: 0`, ask for it
   again with the `sync_contacts` tool or `wazap contacts resync`.
+- **Calls are WhatsApp calls only.** A call shows up as a message with
+  `type: "call"`, carrying its kind, direction, outcome and duration. WhatsApp's
+  own call log and the missed-call notices arrive on their own; a call that
+  starts and ends while wazap is running is recorded live, so calls placed or
+  received while it is stopped can be missing entirely. A cellular call from the
+  phone's dialler is never visible, on any device.
 - **Your phone must stay reachable.** A linked device stops receiving once the
   phone has been offline long enough; `get_status` says so in `hint`.
 

package/dist/calls.js

@@ -0,0 +1,153 @@
+/**
+ * Live calls. Baileys reports a call as a stream of status events and never as
+ * a message, so this folds that stream into one entry per call and hands back a
+ * synthetic WAMessage the ordinary store path can carry. Pure: no timers, no
+ * socket, no store, so a test can drive it by feeding events and a clock.
+ */
+import { proto } from "baileys";
+/** A ringing call nobody answered and nobody hung up: the terminal event was lost. */
+const RING_TIMEOUT_MS = 2 * 60_000;
+/**
+ * An answered call is not expired at the ring timeout, which would invent a
+ * two-minute duration for a conversation still going on. It is only cut loose
+ * once it has run longer than any real call does.
+ */
+const ANSWERED_CAP_MS = 6 * 3_600_000;
+/**
+ * How many settled call ids to remember. They are what makes a repeated
+ * terminal event store nothing twice, and the process is long-lived, so the set
+ * has to forget its oldest eventually rather than grow for the whole session.
+ */
+const SETTLED_MEMORY = 500;
+/** Marks a stored message as one wazap tracked itself. See `isTrackedCall`. */
+const TRACKED_ID_PREFIX = "call_";
+const OUTCOME_CODES = {
+    answered: proto.Message.CallLogMessage.CallOutcome.CONNECTED,
+    rejected: proto.Message.CallLogMessage.CallOutcome.REJECTED,
+    missed: proto.Message.CallLogMessage.CallOutcome.MISSED,
+    unanswered: proto.Message.CallLogMessage.CallOutcome.MISSED,
+};
+function noAnswer(direction) {
+    return direction === "outgoing" ? "unanswered" : "missed";
+}
+/**
+ * `from` arrives as a LID as often as a phone jid, and either can carry a
+ * device suffix, so only the user part of the two jids is comparable.
+ */
+function samePerson(one, other) {
+    const user = (jid) => (jid.split("@")[0] ?? "").split(":")[0] ?? "";
+    const left = user(one);
+    return left.length > 0 && left === user(other);
+}
+export class CallTracker {
+    calls = new Map();
+    settled = new Set();
+    get pending() {
+        return this.calls.size;
+    }
+    /** The entry to store once the call reaches a terminal state, else null. */
+    observe(event, ownJid, now) {
+        if (!event.id || this.settled.has(event.id))
+            return null;
+        const call = this.calls.get(event.id) ?? this.begin(event, ownJid, now);
+        call.lastSeen = now;
+        switch (event.status) {
+            case "accept":
+                call.acceptedAt = now;
+                return null;
+            case "reject":
+                return this.finish(call, "rejected");
+            case "timeout":
+                return this.finish(call, noAnswer(call.direction));
+            case "terminate":
+                return call.acceptedAt === undefined
+                    ? this.finish(call, noAnswer(call.direction))
+                    : this.finish(call, "answered", Math.round((now - call.acceptedAt) / 1000));
+            default:
+                return null;
+        }
+    }
+    /** Entries for calls whose terminal event never arrived. */
+    expire(now) {
+        const done = [];
+        for (const call of [...this.calls.values()]) {
+            if (call.acceptedAt === undefined) {
+                if (now - call.lastSeen >= RING_TIMEOUT_MS)
+                    done.push(this.finish(call, noAnswer(call.direction)));
+            }
+            else if (now - call.acceptedAt >= ANSWERED_CAP_MS) {
+                done.push(this.finish(call, "answered", Math.round((now - call.acceptedAt) / 1000)));
+            }
+        }
+        return done;
+    }
+    /**
+     * An event for an unknown call-id starts a pending call from whatever it
+     * carries, so a restart in the middle of one still records something. Only
+     * the offer names isVideo and the group, which is why baileys replays them
+     * from its own cache onto the later events of the same call.
+     */
+    begin(event, ownJid, now) {
+        const offered = event.date instanceof Date ? event.date.getTime() : Number.NaN;
+        const chat = (event.isGroup ? (event.groupJid ?? event.chatId) : event.chatId) || event.from;
+        const call = {
+            callId: event.id,
+            chatId: chat,
+            at: Number.isFinite(offered) ? offered : now,
+            kind: event.isVideo ? "video" : "voice",
+            direction: samePerson(event.from, ownJid) ? "outgoing" : "incoming",
+            lastSeen: now,
+        };
+        this.calls.set(event.id, call);
+        return call;
+    }
+    finish(call, outcome, durationSeconds) {
+        this.calls.delete(call.callId);
+        this.settled.add(call.callId);
+        if (this.settled.size > SETTLED_MEMORY) {
+            const oldest = this.settled.values().next().value;
+            if (oldest !== undefined)
+                this.settled.delete(oldest);
+        }
+        return {
+            callId: call.callId,
+            chatId: call.chatId,
+            at: call.at,
+            kind: call.kind,
+            direction: call.direction,
+            outcome,
+            ...(durationSeconds === undefined ? {} : { durationSeconds }),
+        };
+    }
+}
+/**
+ * True for a message this tracker built. The tracker emits one entry per call
+ * id, so two of these are always two different calls however close together
+ * they fall, which is the one thing a dedupe by timestamp cannot know.
+ */
+export function isTrackedCall(raw) {
+    return (raw.key?.id ?? "").startsWith(TRACKED_ID_PREFIX);
+}
+/**
+ * The entry as WhatsApp would have logged it, so snapshot, history JSONL, views
+ * and list_chats all carry a live call with no machinery of their own. The
+ * fields have to survive an encode/decode round trip, because that is what
+ * persistence does to it.
+ */
+export function callMessage(entry) {
+    return {
+        key: {
+            remoteJid: entry.chatId,
+            fromMe: entry.direction === "outgoing",
+            id: `${TRACKED_ID_PREFIX}${entry.callId}`,
+        },
+        messageTimestamp: Math.floor(entry.at / 1000),
+        message: {
+            callLogMesssage: {
+                isVideo: entry.kind === "video",
+                callOutcome: OUTCOME_CODES[entry.outcome],
+                ...(entry.durationSeconds === undefined ? {} : { durationSecs: entry.durationSeconds }),
+            },
+        },
+    };
+}

package/dist/messages.js

@@ -165,6 +165,83 @@ function stubKind(raw) {
         return "deleted";
     return stub === proto.WebMessageInfo.StubType.UNKNOWN ? undefined : "system";
 }
+const CALL_OUTCOMES = {
+    [proto.Message.CallLogMessage.CallOutcome.CONNECTED]: "answered",
+    [proto.Message.CallLogMessage.CallOutcome.ACCEPTED_ELSEWHERE]: "answered",
+    [proto.Message.CallLogMessage.CallOutcome.ONGOING]: "answered",
+    [proto.Message.CallLogMessage.CallOutcome.REJECTED]: "rejected",
+    [proto.Message.CallLogMessage.CallOutcome.MISSED]: "no answer",
+    [proto.Message.CallLogMessage.CallOutcome.FAILED]: "no answer",
+    [proto.Message.CallLogMessage.CallOutcome.SILENCED_BY_DND]: "no answer",
+    [proto.Message.CallLogMessage.CallOutcome.SILENCED_UNKNOWN_CALLER]: "no answer",
+};
+const CALL_STUB_KINDS = {
+    [proto.WebMessageInfo.StubType.CALL_MISSED_VOICE]: "voice",
+    [proto.WebMessageInfo.StubType.CALL_MISSED_VIDEO]: "video",
+    [proto.WebMessageInfo.StubType.CALL_MISSED_GROUP_VOICE]: "voice",
+    [proto.WebMessageInfo.StubType.CALL_MISSED_GROUP_VIDEO]: "video",
+};
+function settle(outcome, direction) {
+    if (outcome !== "no answer")
+        return outcome;
+    return direction === "outgoing" ? "unanswered" : "missed";
+}
+/**
+ * Calls never reach the RULES table: `getContentType` looks for a key
+ * containing "Message" and the proto field is spelled `callLogMesssage`, so it
+ * reports undefined and a call arriving next to messageContextInfo would render
+ * as "[system message]". Hence this runs before the table, not inside it.
+ */
+export function callInfo(raw) {
+    const direction = raw.key?.fromMe ? "outgoing" : "incoming";
+    const content = unwrapEnvelopes(raw.message);
+    const logged = content?.callLogMesssage;
+    if (logged) {
+        const outcome = settle(CALL_OUTCOMES[logged.callOutcome ?? -1] ?? "no answer", direction);
+        const seconds = protoNumber(logged.durationSecs);
+        const participants = (logged.participants ?? []).flatMap((one) => (one.jid ? [one.jid] : []));
+        return {
+            kind: logged.isVideo ? "video" : "voice",
+            direction,
+            outcome,
+            ...(outcome === "answered" && seconds !== undefined && seconds > 0 ? { duration_seconds: seconds } : {}),
+            ...(participants.length > 0 ? { participants } : {}),
+        };
+    }
+    const stub = CALL_STUB_KINDS[raw.messageStubType ?? -1];
+    if (stub)
+        return { kind: stub, direction, outcome: settle("no answer", direction) };
+    if (content?.call != null)
+        return { kind: "voice", direction, outcome: settle("no answer", direction) };
+    return undefined;
+}
+/**
+ * Baileys' own stand-in for a group call offer. It says a call happened and
+ * nothing else, so anything that names an outcome outranks it.
+ */
+export function isCallPlaceholder(raw) {
+    const content = unwrapEnvelopes(raw.message);
+    return content?.call != null && content.callLogMesssage == null;
+}
+function durationLabel(seconds) {
+    if (seconds < 60)
+        return `${seconds}s`;
+    const minutes = Math.round(seconds / 60);
+    if (minutes < 60)
+        return `${minutes} min`;
+    const hours = Math.floor(minutes / 60);
+    const rest = minutes % 60;
+    return rest === 0 ? `${hours}h` : `${hours}h ${rest} min`;
+}
+/** An outcome you caused reads as a suffix; one that happened to you is an adjective. */
+export function callText(info) {
+    const duration = info.duration_seconds === undefined ? "" : ` · ${durationLabel(info.duration_seconds)}`;
+    if (info.direction === "outgoing") {
+        return `[outgoing ${info.kind} call${info.outcome === "answered" ? duration : ` · ${info.outcome}`}]`;
+    }
+    const adjective = info.outcome === "answered" ? "" : `${info.outcome} `;
+    return `[${adjective}${info.kind} call${duration}]`;
+}
 function resolve(value, content) {
     return typeof value === "function" ? value(content) : value;
 }
@@ -199,6 +276,8 @@ export function isStubEvent(raw) {
     return stubKind(raw) !== undefined;
 }
 export function messageType(raw) {
+    if (callInfo(raw))
+        return "call";
     const stub = stubKind(raw);
     if (stub === "deleted")
         return "deleted";
@@ -210,6 +289,11 @@ export function messageType(raw) {
 }
 /** Never empty: media and system messages get a placeholder like "[sticker]". */
 export function messageText(raw) {
+    const call = callInfo(raw);
+    // The placeholder only says a group call was offered, so naming an outcome
+    // ("missed") would claim something the payload never carried.
+    if (call)
+        return isCallPlaceholder(raw) ? "[group call]" : callText(call);
     const content = unwrapEnvelopes(raw.message);
     const { rule, content: node } = ruleFor(content);
     if (rule === UNKNOWN) {
@@ -295,6 +379,7 @@ export function buildMessageView(raw, ctx) {
     const media = mediaInfo(raw);
     const context = contextInfo(raw);
     const quoted = context?.quotedMessage ? quotedView(context, ctx) : undefined;
+    const call = callInfo(raw);
     const view = {
         message_id: messageIdFor(raw.key, ctx.chatId),
         chat_id: ctx.chatId,
@@ -316,6 +401,11 @@ export function buildMessageView(raw, ctx) {
         view.media = media;
     if (quoted)
         view.quoted = quoted;
+    if (call) {
+        view.call = call.participants
+            ? { ...call, participants: call.participants.map((jid) => ctx.canonical(jid)) }
+            : call;
+    }
     if (ctx.reactions.length > 0)
         view.reactions = ctx.reactions;
     return view;

package/dist/tools.js

@@ -1,5 +1,6 @@
 import { z } from "zod";
 import { asWazapError, ERROR_GUIDE } from "./errors.js";
+import { MESSAGE_TYPES } from "./wa-types.js";
 function tool(def) {
     return { ...def, handler: def.handler };
 }
@@ -25,6 +26,10 @@ const messageId = z
     .string()
     .min(5)
     .describe('Message id from read_messages / search_messages / get_message, e.g. "false_4072...@s.whatsapp.net_3EB0..."');
+const messageTypes = z
+    .array(z.enum([...MESSAGE_TYPES]))
+    .optional()
+    .describe('Keep only these message types; omit for every type. The limit counts matching messages, so ["call"] returns that many calls, not that many messages of which some are calls.');
 const GUIDE = `# wazap — WhatsApp for your AI agent
 
 Read/write access to the user's linked WhatsApp account: chats, messages, media,
@@ -61,6 +66,11 @@ which look like a phone number and are not one.
 WhatsApp's own notices (device linking, group membership, encryption) have
 \`type: "system"\` and are left out of get_recent_messages unless you pass
 include_system: true.
+A WhatsApp call is a message with \`type: "call"\` carrying
+\`call: {kind, direction, outcome, duration_seconds}\`, reading as
+"[voice call · 6 min]" or "[missed voice call]".
+read_messages and get_recent_messages take \`types\` to narrow to a subset of
+these types, e.g. \`types: ["call"]\` for the call log of a chat.
 \`timestamp\` is ISO 8601 with the machine's UTC offset, \`age\` is human-readable.
 
 ## Errors
@@ -142,11 +152,12 @@ older history when the local store runs out, which takes a few seconds.`,
             chat_id: chatId,
             limit: z.number().int().min(1).max(200).default(20).describe("Maximum number of messages (1-200)"),
             before: messageId.optional().describe("Return the messages immediately older than this message_id"),
+            types: messageTypes,
         },
         write: false,
-        handler: async ({ chat_id, limit, before }, wa) => {
-            const result = await wa.readMessages(chat_id, limit, before);
-            return ok(renderMessages(`Messages in ${chat_id}`, result.data), synced(result, { chat_id, count: result.data.length, messages: result.data }));
+        handler: async ({ chat_id, limit, before, types }, wa) => {
+            const result = await wa.readMessages(chat_id, limit, before, types);
+            return ok(renderMessages(`Messages in ${chat_id}`, result.data), synced(result, { chat_id, types, count: result.data.length, messages: result.data }));
         },
     }),
     tool({
@@ -166,15 +177,17 @@ out so the counts are conversation; pass include_system to see them.`,
                 .boolean()
                 .default(false)
                 .describe("Include WhatsApp's own system notices, which are excluded from the bodies and the counts by default"),
+            types: messageTypes,
         },
         write: false,
-        handler: async ({ hours, filter, include_system }, wa) => {
-            const result = await wa.getRecentMessages(hours, filter, include_system);
+        handler: async ({ hours, filter, include_system, types }, wa) => {
+            const result = await wa.getRecentMessages(hours, filter, include_system, types);
             const messageCount = result.data.reduce((n, c) => n + c.messages.length, 0);
             return ok(renderConversations(result.data, hours), synced(result, {
                 hours,
                 filter,
                 include_system,
+                types,
                 conversation_count: result.data.length,
                 message_count: messageCount,
                 conversations: result.data,

package/dist/wa-types.js

@@ -1,2 +1,20 @@
 /** Public shapes of the WhatsApp service: what the MCP tools and the CLI consume. */
-export {};
+/** The zod enum the tools expose derives from this, so the two cannot drift. */
+export const MESSAGE_TYPES = [
+    "text",
+    "image",
+    "video",
+    "audio",
+    "voice",
+    "document",
+    "sticker",
+    "location",
+    "contact",
+    "poll",
+    "reaction",
+    "deleted",
+    "view_once",
+    "call",
+    "system",
+    "unknown",
+];

package/dist/whatsapp.js

@@ -10,11 +10,12 @@ import { isAbsolute, join } from "node:path";
 import { setTimeout as sleep } from "node:timers/promises";
 import makeWASocket, { ALL_WA_PATCH_NAMES, Browsers, DisconnectReason, downloadMediaMessage, jidNormalizedUser, proto, } from "baileys";
 import { readLinkedAccount, useAtomicAuthState } from "./auth-state.js";
+import { CallTracker, callMessage, isTrackedCall } from "./calls.js";
 import { BAILEYS_VERSION, paths, WAZAP_VERSION } from "./config.js";
 import { asWazapError, RELINK_FIX, RESET_FIX, WazapError } from "./errors.js";
 import { isGroupId, isNoiseJid, resolveChatId } from "./ids.js";
 import { log, logError } from "./logger.js";
-import { buildMessageView, isControlMessage, isStubEvent, isoWithOffset, mediaInfo, messageIdFor, messageText, messageTimestampMs, protoNumber, } from "./messages.js";
+import { buildMessageView, callInfo, isCallPlaceholder, isControlMessage, isStubEvent, isoWithOffset, mediaInfo, messageIdFor, messageText, messageTimestampMs, messageType, protoNumber, } from "./messages.js";
 /** Reconnect pacing. A closed socket used to be retried instantly, which turns
  * any persistent rejection into a login storm — WhatsApp answers that by
  * throttling the account and refusing to link *any* new device to it, phone
@@ -35,6 +36,10 @@ const STALE_INBOUND_MS = 24 * 3_600_000;
 const MAX_MESSAGES_PER_CHAT = 1_000;
 const PERSIST_MESSAGES_PER_CHAT = 120;
 const STORE_SAVE_DEBOUNCE_MS = 20_000;
+const CALL_SWEEP_MS = 30_000;
+/** The same call reaches the store up to three ways; only nearness in time tells them apart. */
+const CALL_DEDUPE_WINDOW_MS = 60_000;
+const CALL_DEDUPE_SCAN = 20;
 const HISTORY_STORE_CAP_PER_CHAT = 2_000;
 const DIR_MODE = 0o700;
 const FILE_MODE = 0o600;
@@ -121,13 +126,35 @@ class Store {
             ring.sort((a, b) => this.seconds(a) - this.seconds(b));
         while (ring.length > MAX_MESSAGES_PER_CHAT) {
             const dropped = ring.shift();
-            if (dropped) {
-                this.messages.delete(dropped);
-                this.chatOf.delete(dropped);
-                this.edited.delete(dropped);
-                this.reactions.delete(dropped);
-            }
+            if (dropped)
+                this.forget(dropped);
+        }
+    }
+    /** The tail of a chat, newest first. */
+    recent(chatJid, count) {
+        const ring = this.byChat.get(chatJid) ?? [];
+        const tail = [];
+        for (let i = ring.length - 1; i >= 0 && tail.length < count; i--) {
+            const sid = ring[i];
+            const raw = this.messages.get(sid);
+            if (raw)
+                tail.push({ sid, raw });
         }
+        return tail;
+    }
+    /** Forget one message entirely, its place in the chat included. */
+    dropMessage(sid) {
+        const ring = this.byChat.get(this.chatOf.get(sid) ?? "");
+        const at = ring?.indexOf(sid) ?? -1;
+        if (ring && at !== -1)
+            ring.splice(at, 1);
+        this.forget(sid);
+    }
+    forget(sid) {
+        this.messages.delete(sid);
+        this.chatOf.delete(sid);
+        this.edited.delete(sid);
+        this.reactions.delete(sid);
     }
     reactionsFor(sid) {
         const map = this.reactions.get(sid);
@@ -227,6 +254,7 @@ export class WhatsAppService {
     historyWaiters = [];
     storeDirty = false;
     storeSaveTimer = null;
+    callSweepTimer = null;
     persistedLoaded = false;
     contactResyncTried = false;
     blocked = new Set();
@@ -238,6 +266,7 @@ export class WhatsAppService {
     /** The same, for naming only, and it holds more. See `learnLidPhone`. */
     lidPhones = new Map();
     store = new Store();
+    calls = new CallTracker();
     paths;
     constructor(config) {
         this.config = config;
@@ -289,6 +318,7 @@ export class WhatsAppService {
         this.storeSaveTimer = null;
         this.reconnectTimer = null;
         this.syncDeadline = null;
+        this.stopCallSweep();
         this.releaseWaiters();
         await this.flushStore();
         this.teardownSocket();
@@ -361,7 +391,7 @@ export class WhatsAppService {
             return this.synced(chats);
         });
     }
-    readMessages(chatId, limit, before) {
+    readMessages(chatId, limit, before, types) {
         return this.guarded(async () => {
             const sock = this.ensureConnected();
             const jid = this.resolveId(chatId);
@@ -369,19 +399,19 @@ export class WhatsAppService {
             await this.learnParticipants(jid);
             await this.learnLidPhones([jid]);
             if (before === undefined) {
-                const ring = this.store.byChat.get(jid) ?? [];
+                const ring = this.ofTypes(this.store.byChat.get(jid) ?? [], types);
                 return this.synced(this.viewsFor(ring.slice(-limit), jid));
             }
             const anchor = this.messageOrThrow(before);
-            let older = this.olderThan(jid, before, limit);
+            let older = this.olderThan(jid, before, limit, types);
             if (older.length === 0) {
                 await this.fetchOlder(sock, anchor, limit);
-                older = this.olderThan(jid, before, limit);
+                older = this.olderThan(jid, before, limit, types);
             }
             return this.synced(this.viewsFor(older, jid));
         });
     }
-    getRecentMessages(hours, filter, includeSystem = false) {
+    getRecentMessages(hours, filter, includeSystem = false, types) {
         return this.guarded(async () => {
             this.ensureConnected();
             await this.waitForSync();
@@ -402,7 +432,7 @@ export class WhatsAppService {
                 });
                 if (recent.length === 0)
                     continue;
-                const messages = this.viewsFor(recent, jid).filter((view) => includeSystem || view.type !== "system");
+                const messages = this.viewsFor(this.ofTypes(recent, types), jid).filter((view) => includeSystem || view.type !== "system");
                 if (messages.length === 0)
                     continue;
                 conversations.push({
@@ -838,6 +868,18 @@ export class WhatsAppService {
                 this.markSyncDone();
             this.markStoreDirty();
         });
+        sock.ev.on("call", ([call]) => {
+            if (generation !== this.generation || !call)
+                return;
+            // WhatsApp addresses a call node by LID as often as by number, and ownJid
+            // is only ever the number, so an outgoing call reads as incoming unless
+            // the two are brought into the same form first.
+            const from = this.canonical(call.from);
+            const entry = this.calls.observe({ ...call, from }, this.ownJid(), Date.now());
+            if (entry)
+                this.storeCall(entry);
+            this.armCallSweep();
+        });
         sock.ev.on("lid-mapping.update", (mapping) => this.learnLid(mapping.lid, mapping.pn));
         sock.ev.on("chats.upsert", (chats) => {
             for (const chat of chats)
@@ -1364,12 +1406,26 @@ export class WhatsAppService {
     viewsFor(sids, chatJid) {
         return sids.filter((sid) => this.store.messages.has(sid)).map((sid) => this.viewOf(sid, chatJid));
     }
-    olderThan(chatJid, before, limit) {
+    /** Absent and empty both mean every type: narrowing is opt-in, never a default. */
+    ofTypes(sids, types) {
+        if (types === undefined || types.length === 0)
+            return sids;
+        return sids.filter((sid) => {
+            const raw = this.store.messages.get(sid);
+            return raw !== undefined && types.includes(messageType(raw));
+        });
+    }
+    /**
+     * The anchor is found in the unfiltered ring, so paging never depends on the
+     * filter, and `limit` then counts messages the caller asked for rather than
+     * messages we are about to throw away.
+     */
+    olderThan(chatJid, before, limit, types) {
         const ring = this.store.byChat.get(chatJid) ?? [];
         const at = ring.indexOf(before);
         if (at <= 0)
             return [];
-        return ring.slice(Math.max(0, at - limit), at);
+        return this.ofTypes(ring.slice(0, at), types).slice(-limit);
     }
     async fetchOlder(sock, anchor, limit) {
         const seconds = Math.floor(messageTimestampMs(anchor) / 1000);
@@ -1499,11 +1555,74 @@ export class WhatsAppService {
             if (isNoiseJid(jid) || isControlMessage(raw))
                 continue;
             this.learnPushName(raw, jid);
-            this.store.putMessage(messageIdFor(raw.key, jid), jid, raw);
+            const sid = messageIdFor(raw.key, jid);
+            if (!this.keepOverEarlierCall(raw, jid, sid))
+                continue;
+            this.store.putMessage(sid, jid, raw);
             stored.push(raw);
         }
         return stored;
     }
+    /**
+     * One call can reach the store three ways: wazap's own tracker, the stub
+     * baileys synthesises on a timeout, and WhatsApp's later call-log message.
+     * Each carries a different id, so only nearness in time pairs them up, and
+     * whichever says more about the call is the one worth keeping. The history
+     * reload runs it too: the JSONL still holds the line the loser wrote before
+     * it was dropped, and a restart would otherwise bring the pair back.
+     */
+    keepOverEarlierCall(raw, chatJid, sid) {
+        const info = callInfo(raw);
+        if (!info)
+            return true;
+        const at = messageTimestampMs(raw);
+        for (const known of this.store.recent(chatJid, CALL_DEDUPE_SCAN)) {
+            if (known.sid === sid)
+                continue;
+            const other = callInfo(known.raw);
+            if (!other)
+                continue;
+            // A redial inside the window is two calls, and wazap knows it built both.
+            if (isTrackedCall(raw) && isTrackedCall(known.raw))
+                continue;
+            if (Math.abs(messageTimestampMs(known.raw) - at) > CALL_DEDUPE_WINDOW_MS)
+                continue;
+            if (callDetail(raw, info) <= callDetail(known.raw, other))
+                return false;
+            this.store.dropMessage(known.sid);
+            return true;
+        }
+        return true;
+    }
+    /** A live call goes in the way any message does, so everything downstream carries it. */
+    storeCall(entry) {
+        const stored = this.ingestMessages([callMessage(entry)]);
+        if (stored.length === 0)
+            return;
+        void this.appendHistory(stored);
+        this.markStoreDirty();
+    }
+    /**
+     * Only while a call is in flight: a call whose terminal event never arrives
+     * would otherwise sit pending forever, and a timer with nothing to do would
+     * otherwise keep ticking for the life of the process.
+     */
+    armCallSweep() {
+        if (this.callSweepTimer || this.calls.pending === 0)
+            return;
+        this.callSweepTimer = setInterval(() => {
+            for (const entry of this.calls.expire(Date.now()))
+                this.storeCall(entry);
+            if (this.calls.pending === 0)
+                this.stopCallSweep();
+        }, CALL_SWEEP_MS);
+        this.callSweepTimer.unref();
+    }
+    stopCallSweep() {
+        if (this.callSweepTimer)
+            clearInterval(this.callSweepTimer);
+        this.callSweepTimer = null;
+    }
     learnPushName(raw, chatJid) {
         const name = raw.pushName?.trim();
         if (!name || raw.key.fromMe)
@@ -1624,6 +1743,8 @@ export class WhatsAppService {
             const jid = this.canonical(raw.key.remoteJid);
             if (isNoiseJid(jid) || isControlMessage(raw))
                 continue;
+            if (!this.keepOverEarlierCall(raw, jid, record.sid))
+                continue;
             this.store.putMessage(record.sid, jid, raw);
             loaded++;
         }
@@ -1674,6 +1795,12 @@ const ADMIN_ACTIONS = new Set([
 const PARTICIPANT_ACTIONS = new Set(["add", "remove", "promote", "demote"]);
 /** WhatsApp answers "cannot add, invite them instead" with these codes. */
 const INVITE_NEEDED_CODES = new Set(["403", "409"]);
+/** How much a call message says. A duration is the most it can carry. */
+function callDetail(raw, info) {
+    if (info.duration_seconds !== undefined)
+        return 2;
+    return isCallPlaceholder(raw) ? 0 : 1;
+}
 function lidKey(lid) {
     return `${jidNormalizedUser(lid).split("@")[0]}@lid`;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wazap-mcp",
-  "version": "0.9.6",
+  "version": "0.9.7",
   "mcpName": "io.github.razvangirgiz/wazap",
   "description": "WhatsApp for your AI agent. MCP server over Baileys: pairing-code login, 22 tools, stdio or token-protected HTTP.",
   "license": "MIT",

package/skills/whatsapp-groups/SKILL.md

@@ -19,7 +19,7 @@ Work through the messages once and collect:
 
 - **Decisions**: something agreed or announced by an admin or by the people it concerns ("ok, Saturday at 10 then").
 - **Dates and deadlines**: any concrete day, time, or "by Friday", with what it is for.
-- **Asks of the user**: every mention or reply to them, plus open questions nobody answered that fall on the user.
+- **Asks of the user**: every mention or reply to them, plus open questions nobody answered that fall on the user. A `call` message in the group after one of these, with `call.outcome` `answered`, means the user was on that group call: say so and treat the ask as probably handled, the way `whatsapp-inbox` does.
 - **Open threads**: questions still without an answer, for anyone.
 - **Polls**: the question and options (`[poll] …`); wazap cannot read votes, so say that if the user asks who voted.
 

package/skills/whatsapp-inbox/SKILL.md

@@ -20,11 +20,20 @@ Done collecting when every chat with unread messages appears in exactly one buck
 Sort each chat into one bucket:
 
 - **Needs you**: a direct question to the user, a request, a mention of the user in a group (`sender` is not the user and the text addresses them or quotes one of their messages), or money/dates/decisions awaiting them.
+- **Probably handled by call**: a *Needs you* candidate the user has since called. See *Calls* below.
 - **FYI**: information with no ask. Shipping updates, "ok thanks", group chatter that reached a conclusion.
 - **Noise**: promotions, broadcast lists, groups the user is muted in (`muted_until` in the future), forwards without a question.
 
 Rank *Needs you* by: people over groups, older unanswered over newer, money and deadlines first.
 
+### Calls
+
+A call after someone's ask is evidence the user dealt with it. For every *Needs you* candidate from an individual chat, look for a `call` message in that chat newer than the ask: the calls already in the window, or `read_messages` on that chat with `types: ["call"]`. A call whose `call.outcome` is `answered` moves the item to *Probably handled by call*, carrying when it was and how long it ran, and ending in a question, because the call may have been about something else:
+
+`Ana — asked about Thursday 10:00; you spoke for 6 min on Tue 14:10. Confirm?`
+
+Missed, rejected and unanswered calls are evidence of nothing, and those items stay in *Needs you*.
+
 ## Report
 
 ```
@@ -33,8 +42,13 @@ Needs you (3)
 2. Bloc 12 group — Mihai needs your vote on the roof quote by Friday. 1d ago.
 3. Dan — sent the contract PDF, waiting for your comments. 2d ago.
 
+Probably handled by call (1)
+1. Ana — asked about Thursday 10:00; you spoke for 6 min on Tue 14:10. Confirm?
+
 FYI: Curier (delivered), Mama (photos), Team (retro moved to Tuesday).
 Noise: 4 promo chats.
 ```
 
+End the report with: *Handled any of these by phone outside WhatsApp? Tell me and I will drop them.* wazap sees WhatsApp calls and never cellular ones, so a call from the phone's own dialler leaves no trace here. Whatever the user answers is authoritative for the rest of the session: drop what they name and do not raise it again.
+
 One line per item: who, what they want, how old. Include the `chat_id` only if the user is likely to act through another tool next. Offer to draft replies only for *Needs you* items; drafting and sending belong to the `whatsapp-send` skill.