@elizaos/agent 2.0.0-alpha.173 → 2.0.0-alpha.192

package/apps/app-lifeops/src/lifeops/unified-search.js

@@ -0,0 +1,431 @@
+/**
+ * Unified cross-channel search (WS1).
+ *
+ * Fans a single semantic query across:
+ *   - Gmail (via LifeOpsService.getGmailSearch)
+ *   - Agent memory (runtime.searchMemories with embedding)
+ *   - WS3 RelationshipsGraphService.getMemoriesForCluster (when a personRef
+ *     resolves to a canonical cluster)
+ *
+ * Connectors that lack first-class search emit a typed `unsupported`
+ * result. We never fabricate hits.
+ *
+ * Architecture note: this file is the orchestrator. The action
+ * (search-across-channels.ts) handles LLM param extraction and result
+ * formatting. The provider (cross-channel-context.ts) consumes
+ * runUnifiedSearch() to inject context for named persons/topics.
+ */
+import { ModelType, logger } from "@elizaos/core";
+// ---------------------------------------------------------------------------
+// Public types
+// ---------------------------------------------------------------------------
+export const UNIFIED_SEARCH_CHANNELS = [
+    "gmail",
+    "memory",
+    "telegram",
+    "discord",
+    "imessage",
+    "whatsapp",
+    "signal",
+    "x-dm",
+    "calendly",
+    "calendar",
+];
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+const DEFAULT_PER_CHANNEL_LIMIT = 10;
+const MEMORY_MATCH_THRESHOLD = 0.55;
+const KNOWN_PLATFORM_FOR_CHANNEL = {
+    gmail: "gmail",
+    memory: "memory",
+    telegram: "telegram",
+    discord: "discord",
+    imessage: "imessage",
+    whatsapp: "whatsapp",
+    signal: "signal",
+    "x-dm": "x",
+    calendly: "calendly",
+    calendar: "calendar",
+};
+function withinTimeWindow(iso, window) {
+    if (!window || (!window.startIso && !window.endIso)) {
+        return true;
+    }
+    if (!iso) {
+        return false;
+    }
+    const t = Date.parse(iso);
+    if (Number.isNaN(t)) {
+        return false;
+    }
+    if (window.startIso) {
+        const start = Date.parse(window.startIso);
+        if (!Number.isNaN(start) && t < start) {
+            return false;
+        }
+    }
+    if (window.endIso) {
+        const end = Date.parse(window.endIso);
+        if (!Number.isNaN(end) && t > end) {
+            return false;
+        }
+    }
+    return true;
+}
+function normalizeIsoFromMs(ms) {
+    if (typeof ms !== "number" || !Number.isFinite(ms)) {
+        return new Date(0).toISOString();
+    }
+    return new Date(ms).toISOString();
+}
+function classifyMemoryChannel(source) {
+    const normalized = (source ?? "").trim().toLowerCase();
+    switch (normalized) {
+        case "telegram":
+            return "telegram";
+        case "discord":
+            return "discord";
+        case "imessage":
+        case "messages":
+            return "imessage";
+        case "whatsapp":
+            return "whatsapp";
+        case "signal":
+            return "signal";
+        case "x":
+        case "twitter":
+        case "x-dm":
+            return "x-dm";
+        case "calendly":
+            return "calendly";
+        case "calendar":
+        case "google-calendar":
+            return "calendar";
+        case "gmail":
+        case "google-gmail":
+        case "email":
+            return "gmail";
+        default:
+            return "memory";
+    }
+}
+function isChannelEnabled(channel, channels) {
+    if (!channels || channels.length === 0) {
+        return true;
+    }
+    return channels.includes(channel);
+}
+async function searchGmail(runtime, query) {
+    const limit = query.limit ?? DEFAULT_PER_CHANNEL_LIMIT;
+    const lifeOps = runtime.getService("lifeops");
+    if (!lifeOps || typeof lifeOps.getGmailSearch !== "function") {
+        return {
+            hits: [],
+            unsupported: [
+                {
+                    channel: "gmail",
+                    reason: "LifeOpsService not registered on runtime",
+                },
+            ],
+            degraded: [],
+        };
+    }
+    const requestUrl = new URL("http://127.0.0.1/api/lifeops/gmail/search");
+    const feed = await lifeOps.getGmailSearch(requestUrl, {
+        query: query.query,
+        maxResults: limit,
+    });
+    const hits = [];
+    for (const msg of feed.messages) {
+        if (!withinTimeWindow(msg.receivedAt, query.timeWindow)) {
+            continue;
+        }
+        hits.push({
+            channel: "gmail",
+            id: `gmail:${msg.id}`,
+            sourceRef: msg.id,
+            timestamp: msg.receivedAt,
+            speaker: msg.from,
+            subject: msg.subject,
+            text: msg.snippet,
+            citation: {
+                platform: "gmail",
+                label: msg.subject || msg.snippet.slice(0, 80),
+                url: msg.htmlLink ?? undefined,
+            },
+        });
+    }
+    return { hits, unsupported: [], degraded: [] };
+}
+async function embedQuery(runtime, text) {
+    const result = await runtime.useModel(ModelType.TEXT_EMBEDDING, { text });
+    if (Array.isArray(result)) {
+        return result;
+    }
+    if (result &&
+        typeof result === "object" &&
+        Array.isArray(result.embedding)) {
+        return result.embedding;
+    }
+    return null;
+}
+async function searchAgentMemory(runtime, query) {
+    const embedding = await embedQuery(runtime, query.query);
+    if (!embedding) {
+        return {
+            hits: [],
+            degraded: [
+                { channel: "memory", reason: "Embedding generation returned no vector" },
+            ],
+        };
+    }
+    const limit = query.limit ?? DEFAULT_PER_CHANNEL_LIMIT;
+    const searchParams = {
+        embedding,
+        tableName: "messages",
+        match_threshold: MEMORY_MATCH_THRESHOLD,
+        limit: limit + 10,
+        worldId: query.worldId,
+    };
+    const memories = await runtime.searchMemories(searchParams);
+    const hits = await memoriesToHits(runtime, memories, query);
+    return { hits, degraded: [] };
+}
+async function memoriesToHits(runtime, memories, query) {
+    const roomCache = new Map();
+    const results = [];
+    for (const mem of memories) {
+        const text = (mem.content?.text ?? "").trim();
+        if (!text)
+            continue;
+        const iso = normalizeIsoFromMs(mem.createdAt);
+        if (!withinTimeWindow(iso, query.timeWindow)) {
+            continue;
+        }
+        const roomId = mem.roomId;
+        let room = null;
+        if (roomId) {
+            if (!roomCache.has(roomId)) {
+                const fetched = await runtime.getRoom(roomId);
+                roomCache.set(roomId, fetched ?? null);
+            }
+            room = roomCache.get(roomId) ?? null;
+        }
+        const roomRecord = room;
+        const platformSource = roomRecord?.source ?? roomRecord?.type;
+        const channel = classifyMemoryChannel(platformSource);
+        if (!isChannelEnabled(channel, query.channels)) {
+            continue;
+        }
+        const speakerEntity = mem.entityId;
+        const memId = mem.id ?? `${roomId}:${mem.createdAt}`;
+        results.push({
+            channel,
+            id: `${channel}:${memId}`,
+            sourceRef: memId,
+            timestamp: iso,
+            speaker: speakerEntity ?? "unknown",
+            text: text.slice(0, 600),
+            citation: {
+                platform: KNOWN_PLATFORM_FOR_CHANNEL[channel],
+                label: roomRecord?.name ?? `room:${(roomId ?? "").slice(0, 8)}`,
+            },
+        });
+    }
+    return results;
+}
+async function resolvePerson(runtime, ref) {
+    if (!ref) {
+        return { service: null, person: null, degraded: [] };
+    }
+    const service = runtime.getService("relationshipsGraph");
+    if (!service) {
+        return {
+            service: null,
+            person: null,
+            degraded: [
+                {
+                    channel: "memory",
+                    reason: "RelationshipsGraphService not registered — falling back to plain semantic search",
+                },
+            ],
+        };
+    }
+    if (ref.primaryEntityId) {
+        const detail = await service.getPersonDetail(ref.primaryEntityId);
+        if (detail) {
+            return { service, person: detail, degraded: [] };
+        }
+    }
+    const search = ref.displayName?.trim();
+    if (!search) {
+        return { service, person: null, degraded: [] };
+    }
+    const snapshot = await service.getGraphSnapshot({ search, limit: 5 });
+    const person = snapshot.people[0] ?? null;
+    return { service, person, degraded: [] };
+}
+async function searchClusterMemories(runtime, service, person, query) {
+    const fn = service.getMemoriesForCluster;
+    if (typeof fn !== "function") {
+        return {
+            hits: [],
+            degraded: [
+                {
+                    channel: "memory",
+                    reason: "RelationshipsGraphService.getMemoriesForCluster not implemented yet",
+                },
+            ],
+        };
+    }
+    const memories = await fn({
+        primaryEntityId: person.primaryEntityId,
+        count: (query.limit ?? DEFAULT_PER_CHANNEL_LIMIT) * 2,
+        worldId: query.worldId,
+    });
+    const hits = await memoriesToHits(runtime, memories, query);
+    return { hits, degraded: [] };
+}
+// ---------------------------------------------------------------------------
+// Connector adapters that don't yet have first-class search
+// ---------------------------------------------------------------------------
+const CONNECTORS_WITHOUT_NATIVE_SEARCH = [
+    {
+        channel: "telegram",
+        reason: "Telegram MTProto search not wired — covered by memory fan-out only",
+    },
+    {
+        channel: "discord",
+        reason: "Discord browser scraper does not expose search",
+    },
+    {
+        channel: "imessage",
+        reason: "iMessage bridge does not expose search",
+    },
+    {
+        channel: "whatsapp",
+        reason: "WhatsApp connector does not expose search",
+    },
+    {
+        channel: "signal",
+        reason: "Signal connector does not expose search",
+    },
+    {
+        channel: "x-dm",
+        reason: "X DM connector does not expose search",
+    },
+];
+// ---------------------------------------------------------------------------
+// Result merge
+// ---------------------------------------------------------------------------
+function dedupeHits(hits) {
+    const seen = new Set();
+    const out = [];
+    for (const hit of hits) {
+        if (seen.has(hit.id))
+            continue;
+        seen.add(hit.id);
+        out.push(hit);
+    }
+    return out;
+}
+function rankHits(hits) {
+    return [...hits].sort((a, b) => {
+        const ta = Date.parse(a.timestamp);
+        const tb = Date.parse(b.timestamp);
+        if (Number.isNaN(ta) && Number.isNaN(tb))
+            return 0;
+        if (Number.isNaN(ta))
+            return 1;
+        if (Number.isNaN(tb))
+            return -1;
+        return tb - ta;
+    });
+}
+// ---------------------------------------------------------------------------
+// Public entry point
+// ---------------------------------------------------------------------------
+export async function runUnifiedSearch(runtime, query) {
+    if (!query.query || query.query.trim().length === 0) {
+        throw new Error("runUnifiedSearch: query.query is required");
+    }
+    const channels = query.channels;
+    const unsupported = [];
+    const degraded = [];
+    const allHits = [];
+    // 1. Resolve canonical person via WS3 (best-effort).
+    const personResolution = await resolvePerson(runtime, query.personRef);
+    degraded.push(...personResolution.degraded);
+    // 2. Fan out in parallel.
+    const tasks = [];
+    if (isChannelEnabled("gmail", channels)) {
+        tasks.push((async () => {
+            try {
+                const r = await searchGmail(runtime, query);
+                allHits.push(...r.hits);
+                unsupported.push(...r.unsupported);
+                degraded.push(...r.degraded);
+            }
+            catch (err) {
+                degraded.push({
+                    channel: "gmail",
+                    reason: `Gmail search failed: ${err instanceof Error ? err.message : String(err)}`,
+                });
+            }
+        })());
+    }
+    if (isChannelEnabled("memory", channels)) {
+        tasks.push((async () => {
+            try {
+                const r = await searchAgentMemory(runtime, query);
+                allHits.push(...r.hits);
+                degraded.push(...r.degraded);
+            }
+            catch (err) {
+                degraded.push({
+                    channel: "memory",
+                    reason: `Memory search failed: ${err instanceof Error ? err.message : String(err)}`,
+                });
+            }
+        })());
+    }
+    if (personResolution.service && personResolution.person) {
+        tasks.push((async () => {
+            try {
+                const r = await searchClusterMemories(runtime, personResolution.service, personResolution.person, query);
+                allHits.push(...r.hits);
+                degraded.push(...r.degraded);
+            }
+            catch (err) {
+                degraded.push({
+                    channel: "memory",
+                    reason: `Cluster fan-out failed: ${err instanceof Error ? err.message : String(err)}`,
+                });
+            }
+        })());
+    }
+    await Promise.all(tasks);
+    // 3. Emit unsupported markers for connectors without native search, only
+    //    when the caller explicitly asked for that channel (so we don't spam
+    //    every result with the full list).
+    for (const entry of CONNECTORS_WITHOUT_NATIVE_SEARCH) {
+        if (channels && channels.includes(entry.channel)) {
+            unsupported.push(entry);
+        }
+    }
+    // 4. Dedupe + rank.
+    const merged = rankHits(dedupeHits(allHits));
+    const channelsWithHits = Array.from(new Set(merged.map((h) => h.channel)));
+    const finalLimit = (query.limit ?? DEFAULT_PER_CHANNEL_LIMIT) * UNIFIED_SEARCH_CHANNELS.length;
+    const limited = merged.slice(0, finalLimit);
+    logger.debug(`[unified-search] query="${query.query}" hits=${limited.length} unsupported=${unsupported.length} degraded=${degraded.length}`);
+    return {
+        query: query.query,
+        hits: limited,
+        unsupported,
+        degraded,
+        channelsWithHits,
+        resolvedPerson: personResolution.person,
+    };
+}

package/apps/app-lifeops/src/lifeops/whatsapp-client.d.ts

@@ -0,0 +1,47 @@
+export interface WhatsAppCredentials {
+    accessToken: string;
+    phoneNumberId: string;
+    apiVersion?: string;
+}
+export interface WhatsAppMessage {
+    id: string;
+    from: string;
+    timestamp: string;
+    type: "text" | "image" | "audio" | "document" | "unknown";
+    text?: string;
+    mediaId?: string;
+}
+export interface WhatsAppSendRequest {
+    to: string;
+    text: string;
+    replyToMessageId?: string;
+}
+export declare class WhatsAppError extends Error {
+    readonly status: number;
+    readonly body?: unknown;
+    constructor(message: string, status: number, body?: unknown);
+}
+export declare function readWhatsAppCredentialsFromEnv(env?: NodeJS.ProcessEnv): WhatsAppCredentials | null;
+export declare function sendWhatsAppMessage(creds: WhatsAppCredentials, req: WhatsAppSendRequest): Promise<{
+    ok: true;
+    messageId: string;
+}>;
+/**
+ * Parse a raw WhatsApp webhook payload, buffer the resulting messages for
+ * periodic drain by {@link drainWhatsAppInboundBuffer}, and return the parsed
+ * messages.
+ */
+export declare function parseAndBufferWhatsAppWebhookMessages(payload: unknown): WhatsAppMessage[];
+/**
+ * Drain all buffered inbound messages and clear the buffer.
+ * Used by {@link syncWhatsAppInbound} in the service mixin to implement
+ * periodic pull semantics on top of the webhook-only inbound path.
+ */
+export declare function drainWhatsAppInboundBuffer(): WhatsAppMessage[];
+/**
+ * Peek at buffered messages without clearing the buffer.
+ * Useful for status checks.
+ */
+export declare function peekWhatsAppInboundBuffer(): WhatsAppMessage[];
+export declare function parseWhatsAppWebhookMessages(payload: unknown): WhatsAppMessage[];
+//# sourceMappingURL=whatsapp-client.d.ts.map

package/apps/app-lifeops/src/lifeops/whatsapp-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"whatsapp-client.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-lifeops/src/lifeops/whatsapp-client.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,mBAAmB;IAClC,WAAW,EAAE,MAAM,CAAC;IACpB,aAAa,EAAE,MAAM,CAAC;IACtB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,eAAe;IAC9B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,GAAG,OAAO,GAAG,OAAO,GAAG,UAAU,GAAG,SAAS,CAAC;IAC1D,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,mBAAmB;IAClC,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED,qBAAa,aAAc,SAAQ,KAAK;aAGpB,MAAM,EAAE,MAAM;aACd,IAAI,CAAC,EAAE,OAAO;gBAF9B,OAAO,EAAE,MAAM,EACC,MAAM,EAAE,MAAM,EACd,IAAI,CAAC,EAAE,OAAO;CAKjC;AAMD,wBAAgB,8BAA8B,CAC5C,GAAG,GAAE,MAAM,CAAC,UAAwB,GACnC,mBAAmB,GAAG,IAAI,CAY5B;AAED,wBAAsB,mBAAmB,CACvC,KAAK,EAAE,mBAAmB,EAC1B,GAAG,EAAE,mBAAmB,GACvB,OAAO,CAAC;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAAC,CAqD1C;AA0CD;;;;GAIG;AACH,wBAAgB,qCAAqC,CACnD,OAAO,EAAE,OAAO,GACf,eAAe,EAAE,CAMnB;AAED;;;;GAIG;AACH,wBAAgB,0BAA0B,IAAI,eAAe,EAAE,CAI9D;AAED;;;GAGG;AACH,wBAAgB,yBAAyB,IAAI,eAAe,EAAE,CAE7D;AAED,wBAAgB,4BAA4B,CAAC,OAAO,EAAE,OAAO,GAAG,eAAe,EAAE,CA0EhF"}

package/apps/app-lifeops/src/lifeops/whatsapp-client.js

@@ -0,0 +1,198 @@
+import { logger } from "@elizaos/core";
+export class WhatsAppError extends Error {
+    status;
+    body;
+    constructor(message, status, body) {
+        super(message);
+        this.status = status;
+        this.body = body;
+        this.name = "WhatsAppError";
+    }
+}
+const DEFAULT_API_VERSION = "v21.0";
+const WHATSAPP_BASE_URL = process.env.MILADY_MOCK_WHATSAPP_BASE ?? "https://graph.facebook.com";
+export function readWhatsAppCredentialsFromEnv(env = process.env) {
+    const accessToken = env.ELIZA_WHATSAPP_ACCESS_TOKEN?.trim();
+    const phoneNumberId = env.ELIZA_WHATSAPP_PHONE_NUMBER_ID?.trim();
+    if (!accessToken || !phoneNumberId) {
+        return null;
+    }
+    const apiVersion = env.ELIZA_WHATSAPP_API_VERSION?.trim() || undefined;
+    return {
+        accessToken,
+        phoneNumberId,
+        ...(apiVersion ? { apiVersion } : {}),
+    };
+}
+export async function sendWhatsAppMessage(creds, req) {
+    const apiVersion = creds.apiVersion ?? DEFAULT_API_VERSION;
+    const url = `${WHATSAPP_BASE_URL}/${apiVersion}/${encodeURIComponent(creds.phoneNumberId)}/messages`;
+    const payload = {
+        messaging_product: "whatsapp",
+        to: req.to,
+        type: "text",
+        text: { body: req.text },
+    };
+    if (req.replyToMessageId) {
+        payload.context = { message_id: req.replyToMessageId };
+    }
+    const response = await fetch(url, {
+        method: "POST",
+        headers: {
+            Authorization: `Bearer ${creds.accessToken}`,
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify(payload),
+        signal: AbortSignal.timeout(12_000),
+    });
+    const body = (await response.json().catch(() => ({})));
+    if (!response.ok) {
+        const errorMessage = body.error?.message ?? `WhatsApp request failed with HTTP ${response.status}`;
+        logger.warn({
+            boundary: "lifeops",
+            integration: "whatsapp",
+            operation: "whatsapp_send",
+            statusCode: response.status,
+        }, `[lifeops] WhatsApp send failed: ${errorMessage}`);
+        throw new WhatsAppError(errorMessage, response.status, body);
+    }
+    const messageId = body.messages?.[0]?.id;
+    if (!messageId) {
+        throw new WhatsAppError("WhatsApp response missing message id", response.status, body);
+    }
+    return { ok: true, messageId };
+}
+function mapMessageType(raw) {
+    if (raw === "text" || raw === "image" || raw === "audio" || raw === "document") {
+        return raw;
+    }
+    return "unknown";
+}
+// ---------------------------------------------------------------------------
+// Inbound message buffer
+// ---------------------------------------------------------------------------
+// WhatsApp Business Cloud API provides no "list messages" endpoint — inbound
+// messages arrive exclusively via webhook push. This buffer holds the last
+// MAX_BUFFER_SIZE messages received via webhook so that the service mixin can
+// expose a periodic sync / drain call without re-ingesting duplicates.
+const MAX_BUFFER_SIZE = 500;
+const inboundBuffer = new Map();
+/**
+ * Add messages to the module-level inbound buffer, deduplicating by message id.
+ * Oldest entries are evicted when the buffer exceeds {@link MAX_BUFFER_SIZE}.
+ *
+ * @internal Called automatically by {@link parseAndBufferWhatsAppWebhookMessages}.
+ */
+function bufferInboundMessages(messages) {
+    for (const message of messages) {
+        inboundBuffer.set(message.id, message);
+    }
+    // Evict oldest entries when over capacity.
+    if (inboundBuffer.size > MAX_BUFFER_SIZE) {
+        const toDelete = inboundBuffer.size - MAX_BUFFER_SIZE;
+        let deleted = 0;
+        for (const key of inboundBuffer.keys()) {
+            inboundBuffer.delete(key);
+            deleted++;
+            if (deleted >= toDelete)
+                break;
+        }
+    }
+}
+/**
+ * Parse a raw WhatsApp webhook payload, buffer the resulting messages for
+ * periodic drain by {@link drainWhatsAppInboundBuffer}, and return the parsed
+ * messages.
+ */
+export function parseAndBufferWhatsAppWebhookMessages(payload) {
+    const messages = parseWhatsAppWebhookMessages(payload);
+    if (messages.length > 0) {
+        bufferInboundMessages(messages);
+    }
+    return messages;
+}
+/**
+ * Drain all buffered inbound messages and clear the buffer.
+ * Used by {@link syncWhatsAppInbound} in the service mixin to implement
+ * periodic pull semantics on top of the webhook-only inbound path.
+ */
+export function drainWhatsAppInboundBuffer() {
+    const messages = [...inboundBuffer.values()];
+    inboundBuffer.clear();
+    return messages;
+}
+/**
+ * Peek at buffered messages without clearing the buffer.
+ * Useful for status checks.
+ */
+export function peekWhatsAppInboundBuffer() {
+    return [...inboundBuffer.values()];
+}
+export function parseWhatsAppWebhookMessages(payload) {
+    if (!payload || typeof payload !== "object") {
+        return [];
+    }
+    const entries = payload.entry;
+    if (!Array.isArray(entries)) {
+        return [];
+    }
+    const messages = [];
+    for (const entry of entries) {
+        if (!entry || typeof entry !== "object")
+            continue;
+        const changes = entry.changes;
+        if (!Array.isArray(changes))
+            continue;
+        for (const change of changes) {
+            if (!change || typeof change !== "object")
+                continue;
+            const value = change.value;
+            if (!value || typeof value !== "object")
+                continue;
+            const rawMessages = value.messages;
+            if (!Array.isArray(rawMessages))
+                continue;
+            for (const msg of rawMessages) {
+                if (!msg || typeof msg !== "object")
+                    continue;
+                const m = msg;
+                if (typeof m.id !== "string" || typeof m.from !== "string")
+                    continue;
+                // WhatsApp timestamps are unix seconds as string; convert to ISO.
+                let isoTimestamp;
+                if (typeof m.timestamp === "string") {
+                    const asNumber = Number(m.timestamp);
+                    isoTimestamp = Number.isFinite(asNumber)
+                        ? new Date(asNumber * 1000).toISOString()
+                        : new Date().toISOString();
+                }
+                else if (typeof m.timestamp === "number") {
+                    isoTimestamp = new Date(m.timestamp * 1000).toISOString();
+                }
+                else {
+                    isoTimestamp = new Date().toISOString();
+                }
+                const type = mapMessageType(m.type);
+                const text = type === "text" && typeof m.text?.body === "string"
+                    ? m.text.body
+                    : undefined;
+                const mediaId = type === "image" && typeof m.image?.id === "string"
+                    ? m.image.id
+                    : type === "audio" && typeof m.audio?.id === "string"
+                        ? m.audio.id
+                        : type === "document" && typeof m.document?.id === "string"
+                            ? m.document.id
+                            : undefined;
+                messages.push({
+                    id: m.id,
+                    from: m.from,
+                    timestamp: isoTimestamp,
+                    type,
+                    ...(text !== undefined ? { text } : {}),
+                    ...(mediaId !== undefined ? { mediaId } : {}),
+                });
+            }
+        }
+    }
+    return messages;
+}