@elizaos/plugin-personal-assistant 2.0.3-beta.5 → 2.0.3-beta.7

package/dist/lifeops/cross-channel-search.js

@@ -0,0 +1,888 @@
+import { logger, ModelType, runWithTrajectoryContext } from "@elizaos/core";
+async function getClusterMemories(runtime, primaryEntityId, params) {
+  return runtime.getMemories({
+    tableName: params.tableName,
+    worldId: params.worldId,
+    count: params.count,
+    entityId: primaryEntityId
+  });
+}
+const CROSS_CHANNEL_SEARCH_CHANNELS = [
+  "gmail",
+  "memory",
+  "telegram",
+  "discord",
+  "imessage",
+  "whatsapp",
+  "signal",
+  "x",
+  "x-dm",
+  "calendly",
+  "calendar"
+];
+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: "x",
+  "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 (/* @__PURE__ */ 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":
+      return "x";
+    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);
+}
+function isObjectService(value) {
+  return Boolean(value) && typeof value === "object";
+}
+function getLifeOpsSearchService(runtime) {
+  const service = runtime.getService("lifeops");
+  if (!isObjectService(service)) {
+    return null;
+  }
+  const candidate = service;
+  return typeof candidate.getGmailSearch === "function" ? service : null;
+}
+async function searchGmail(runtime, query) {
+  const limit = query.limit ?? DEFAULT_PER_CHANNEL_LIMIT;
+  const lifeOps = getLifeOpsSearchService(runtime);
+  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 ?? void 0
+      }
+    });
+  }
+  return { hits, unsupported: [], degraded: [] };
+}
+async function searchTelegram(runtime, query) {
+  const lifeOps = getLifeOpsSearchService(runtime);
+  if (!lifeOps || typeof lifeOps.searchTelegramMessages !== "function") {
+    return {
+      hits: [],
+      unsupported: [
+        {
+          channel: "telegram",
+          reason: "Telegram search is not available on LifeOpsService"
+        }
+      ]
+    };
+  }
+  const limit = query.limit ?? DEFAULT_PER_CHANNEL_LIMIT;
+  const messages = await lifeOps.searchTelegramMessages({
+    query: query.query,
+    limit
+  });
+  const hits = [];
+  for (const msg of messages) {
+    if (!withinTimeWindow(msg.timestamp ?? void 0, query.timeWindow)) {
+      continue;
+    }
+    const sourceRef = msg.id ?? msg.dialogId ?? msg.content.slice(0, 48);
+    hits.push({
+      channel: "telegram",
+      id: `telegram:${sourceRef}`,
+      sourceRef,
+      timestamp: msg.timestamp ?? (/* @__PURE__ */ new Date(0)).toISOString(),
+      speaker: msg.outgoing ? "me" : msg.username ?? "unknown",
+      text: msg.content,
+      citation: {
+        platform: "telegram",
+        label: msg.dialogTitle ?? msg.username ?? "Telegram"
+      }
+    });
+  }
+  return { hits, unsupported: [] };
+}
+async function searchDiscord(runtime, query) {
+  const lifeOps = getLifeOpsSearchService(runtime);
+  if (!lifeOps || typeof lifeOps.searchDiscordMessages !== "function") {
+    return {
+      hits: [],
+      unsupported: [
+        {
+          channel: "discord",
+          reason: "Discord search is not available on LifeOpsService"
+        }
+      ]
+    };
+  }
+  const messages = await lifeOps.searchDiscordMessages({ query: query.query });
+  const hits = [];
+  for (const msg of messages) {
+    if (!withinTimeWindow(msg.timestamp ?? void 0, query.timeWindow)) {
+      continue;
+    }
+    const sourceRef = msg.id ?? msg.channelId ?? msg.content.slice(0, 48);
+    hits.push({
+      channel: "discord",
+      id: `discord:${sourceRef}`,
+      sourceRef,
+      timestamp: msg.timestamp ?? (/* @__PURE__ */ new Date(0)).toISOString(),
+      speaker: msg.authorName ?? "unknown",
+      text: msg.content,
+      citation: {
+        platform: "discord",
+        label: msg.channelId ? `channel:${msg.channelId}` : "Discord"
+      }
+    });
+  }
+  return { hits, unsupported: [] };
+}
+async function searchIMessages(runtime, query) {
+  const lifeOps = getLifeOpsSearchService(runtime);
+  if (!lifeOps || typeof lifeOps.searchIMessages !== "function") {
+    return {
+      hits: [],
+      unsupported: [
+        {
+          channel: "imessage",
+          reason: "iMessage search is not available on LifeOpsService"
+        }
+      ]
+    };
+  }
+  const limit = query.limit ?? DEFAULT_PER_CHANNEL_LIMIT;
+  const messages = await lifeOps.searchIMessages({
+    query: query.query,
+    limit
+  });
+  const hits = [];
+  for (const msg of messages) {
+    if (!withinTimeWindow(msg.sentAt, query.timeWindow)) {
+      continue;
+    }
+    hits.push({
+      channel: "imessage",
+      id: `imessage:${msg.id}`,
+      sourceRef: msg.id,
+      timestamp: msg.sentAt,
+      speaker: msg.isFromMe ? "me" : msg.fromHandle,
+      text: msg.text,
+      citation: {
+        platform: "imessage",
+        label: msg.chatId ?? msg.fromHandle
+      }
+    });
+  }
+  return { hits, unsupported: [] };
+}
+async function searchSignal(runtime, query) {
+  const lifeOps = getLifeOpsSearchService(runtime);
+  if (!lifeOps || typeof lifeOps.readSignalInbound !== "function") {
+    return {
+      hits: [],
+      unsupported: [
+        {
+          channel: "signal",
+          reason: "Signal passive read is not available on LifeOpsService"
+        }
+      ]
+    };
+  }
+  const limit = query.limit ?? DEFAULT_PER_CHANNEL_LIMIT;
+  const needle = query.query.trim().toLowerCase();
+  const messages = await lifeOps.readSignalInbound(limit + 25);
+  const hits = [];
+  for (const msg of messages) {
+    const timestamp = normalizeIsoFromMs(msg.createdAt);
+    if (!withinTimeWindow(timestamp, query.timeWindow)) {
+      continue;
+    }
+    if (needle && !msg.text.toLowerCase().includes(needle)) {
+      continue;
+    }
+    hits.push({
+      channel: "signal",
+      id: `signal:${msg.id}`,
+      sourceRef: msg.id,
+      timestamp,
+      speaker: msg.speakerName ?? msg.senderNumber ?? "unknown",
+      text: msg.text,
+      citation: {
+        platform: "signal",
+        label: msg.roomName ?? msg.threadId ?? "Signal"
+      }
+    });
+  }
+  return { hits: hits.slice(0, limit), unsupported: [] };
+}
+async function searchWhatsApp(runtime, query) {
+  const lifeOps = getLifeOpsSearchService(runtime);
+  if (!lifeOps || typeof lifeOps.pullWhatsAppRecent !== "function") {
+    return {
+      hits: [],
+      unsupported: [
+        {
+          channel: "whatsapp",
+          reason: "WhatsApp passive read is not available on LifeOpsService"
+        }
+      ]
+    };
+  }
+  const limit = query.limit ?? DEFAULT_PER_CHANNEL_LIMIT;
+  const needle = query.query.trim().toLowerCase();
+  const recent = await lifeOps.pullWhatsAppRecent(limit + 25);
+  const hits = [];
+  for (const msg of recent.messages) {
+    const text = msg.text?.trim();
+    if (!text) {
+      continue;
+    }
+    if (!withinTimeWindow(msg.timestamp, query.timeWindow)) {
+      continue;
+    }
+    if (needle && !text.toLowerCase().includes(needle)) {
+      continue;
+    }
+    hits.push({
+      channel: "whatsapp",
+      id: `whatsapp:${msg.id}`,
+      sourceRef: msg.id,
+      timestamp: msg.timestamp,
+      speaker: msg.metadata?.contactName ?? msg.from,
+      text,
+      citation: {
+        platform: "whatsapp",
+        label: msg.metadata?.contactName ?? msg.channelId
+      }
+    });
+  }
+  return { hits: hits.slice(0, limit), unsupported: [] };
+}
+function searchableCalendarText(event) {
+  return [
+    event.title,
+    event.description,
+    event.location,
+    event.organizer && typeof event.organizer === "object" ? JSON.stringify(event.organizer) : "",
+    ...event.attendees.map(
+      (attendee) => [attendee.displayName, attendee.email].filter(Boolean).join(" ")
+    )
+  ].filter(Boolean).join(" ").toLowerCase();
+}
+async function searchCalendar(runtime, query) {
+  const lifeOps = getLifeOpsSearchService(runtime);
+  if (!lifeOps || typeof lifeOps.getCalendarFeed !== "function") {
+    return {
+      hits: [],
+      unsupported: [
+        {
+          channel: "calendar",
+          reason: "Calendar feed is not available on LifeOpsService"
+        }
+      ]
+    };
+  }
+  const feed = await lifeOps.getCalendarFeed(
+    new URL("http://127.0.0.1/api/lifeops/calendar/feed"),
+    {
+      timeMin: query.timeWindow?.startIso,
+      timeMax: query.timeWindow?.endIso,
+      includeHiddenCalendars: true
+    }
+  );
+  const needle = query.query.trim().toLowerCase();
+  const hits = [];
+  for (const event of feed.events) {
+    if (!withinTimeWindow(event.startAt, query.timeWindow)) {
+      continue;
+    }
+    if (needle && !searchableCalendarText(event).includes(needle)) {
+      continue;
+    }
+    const organizer = event.organizer && typeof event.organizer === "object" ? event.organizer : null;
+    hits.push({
+      channel: "calendar",
+      id: `calendar:${event.id}`,
+      sourceRef: event.id,
+      timestamp: event.startAt,
+      speaker: typeof organizer?.displayName === "string" ? organizer.displayName : typeof organizer?.email === "string" ? organizer.email : "calendar",
+      subject: event.title,
+      text: [event.title, event.description, event.location].filter(Boolean).join(" \u2014 "),
+      citation: {
+        platform: "calendar",
+        label: event.title,
+        url: event.htmlLink ?? event.conferenceLink ?? void 0
+      }
+    });
+  }
+  return { hits, unsupported: [] };
+}
+function xStatusUrl(item) {
+  const tweetId = item.externalTweetId.trim();
+  if (!tweetId) return void 0;
+  const handle = item.authorHandle.replace(/^@/, "").trim();
+  return handle ? `https://x.com/${encodeURIComponent(handle)}/status/${encodeURIComponent(tweetId)}` : `https://x.com/i/web/status/${encodeURIComponent(tweetId)}`;
+}
+async function searchXPostsChannel(runtime, query) {
+  const lifeOps = getLifeOpsSearchService(runtime);
+  if (!lifeOps || typeof lifeOps.searchXPosts !== "function") {
+    return {
+      hits: [],
+      unsupported: [
+        {
+          channel: "x",
+          reason: "X post search is not available on LifeOpsService"
+        }
+      ]
+    };
+  }
+  const limit = query.limit ?? DEFAULT_PER_CHANNEL_LIMIT;
+  const posts = await lifeOps.searchXPosts(query.query, { limit });
+  const hits = [];
+  for (const post of posts) {
+    if (!withinTimeWindow(post.createdAtSource, query.timeWindow)) {
+      continue;
+    }
+    hits.push({
+      channel: "x",
+      id: `x:${post.externalTweetId || post.id}`,
+      sourceRef: post.id,
+      timestamp: post.createdAtSource,
+      speaker: post.authorHandle,
+      text: post.text,
+      citation: {
+        platform: "x",
+        label: post.authorHandle,
+        url: xStatusUrl(post)
+      }
+    });
+  }
+  return { hits, unsupported: [] };
+}
+async function searchXDms(runtime, query) {
+  const lifeOps = getLifeOpsSearchService(runtime);
+  if (!lifeOps || typeof lifeOps.getXDms !== "function") {
+    return {
+      hits: [],
+      unsupported: [
+        {
+          channel: "x-dm",
+          reason: "X DM search is not available on LifeOpsService"
+        }
+      ]
+    };
+  }
+  const limit = query.limit ?? DEFAULT_PER_CHANNEL_LIMIT;
+  const needle = query.query.trim().toLowerCase();
+  const dms = await lifeOps.getXDms({ limit: limit + 10 });
+  const hits = [];
+  for (const dm of dms) {
+    if (!withinTimeWindow(dm.receivedAt, query.timeWindow)) {
+      continue;
+    }
+    if (needle && !dm.text.toLowerCase().includes(needle)) {
+      continue;
+    }
+    hits.push({
+      channel: "x-dm",
+      id: `x-dm:${dm.id}`,
+      sourceRef: dm.id,
+      timestamp: dm.receivedAt,
+      speaker: dm.isInbound ? dm.senderHandle : "me",
+      text: dm.text,
+      citation: {
+        platform: "x",
+        label: dm.senderHandle || dm.conversationId
+      }
+    });
+  }
+  return { hits: hits.slice(0, limit), unsupported: [] };
+}
+async function embedQuery(runtime, text) {
+  const result = await runWithTrajectoryContext(
+    { purpose: "lifeops-cross-channel-search-embedding" },
+    () => 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 = /* @__PURE__ */ 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;
+}
+function isRelationshipsGraphServiceWithCluster(service) {
+  if (!isObjectService(service)) return false;
+  const candidate = service;
+  return typeof candidate.getGraphSnapshot === "function" && typeof candidate.getPersonDetail === "function";
+}
+async function resolvePerson(runtime, ref) {
+  if (!ref) {
+    return { service: null, person: null, degraded: [] };
+  }
+  const candidateService = runtime.getService("relationships");
+  const baseService = isRelationshipsGraphServiceWithCluster(candidateService) ? candidateService : null;
+  const service = baseService ? {
+    ...baseService,
+    getMemoriesForCluster: baseService.getMemoriesForCluster ?? ((args) => getClusterMemories(runtime, args.primaryEntityId, {
+      tableName: "messages",
+      worldId: args.worldId,
+      count: args.count
+    }))
+  } : null;
+  if (!service) {
+    return {
+      service: null,
+      person: null,
+      degraded: [
+        {
+          channel: "memory",
+          reason: "RelationshipsGraphService not registered \u2014 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 is unavailable on the registered service"
+        }
+      ]
+    };
+  }
+  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: [] };
+}
+const CONNECTORS_WITHOUT_NATIVE_SEARCH = [
+  {
+    channel: "calendly",
+    reason: "Calendly search is not available on LifeOpsService"
+  }
+];
+function dedupeHits(hits) {
+  const seen = /* @__PURE__ */ 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;
+  });
+}
+async function runCrossChannelSearch(runtime, query) {
+  if (query.query.trim().length === 0) {
+    throw new Error("runCrossChannelSearch: query.query is required");
+  }
+  const channels = query.channels;
+  const unsupported = [];
+  const degraded = [];
+  const allHits = [];
+  const personResolution = await resolvePerson(runtime, query.personRef);
+  degraded.push(...personResolution.degraded);
+  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("telegram", channels)) {
+    tasks.push(
+      (async () => {
+        try {
+          const r = await searchTelegram(runtime, query);
+          allHits.push(...r.hits);
+          unsupported.push(...r.unsupported);
+        } catch (err) {
+          degraded.push({
+            channel: "telegram",
+            reason: `Telegram search failed: ${err instanceof Error ? err.message : String(err)}`
+          });
+        }
+      })()
+    );
+  }
+  if (isChannelEnabled("discord", channels)) {
+    tasks.push(
+      (async () => {
+        try {
+          const r = await searchDiscord(runtime, query);
+          allHits.push(...r.hits);
+          unsupported.push(...r.unsupported);
+        } catch (err) {
+          degraded.push({
+            channel: "discord",
+            reason: `Discord search failed: ${err instanceof Error ? err.message : String(err)}`
+          });
+        }
+      })()
+    );
+  }
+  if (isChannelEnabled("imessage", channels)) {
+    tasks.push(
+      (async () => {
+        try {
+          const r = await searchIMessages(runtime, query);
+          allHits.push(...r.hits);
+          unsupported.push(...r.unsupported);
+        } catch (err) {
+          degraded.push({
+            channel: "imessage",
+            reason: `iMessage search failed: ${err instanceof Error ? err.message : String(err)}`
+          });
+        }
+      })()
+    );
+  }
+  if (isChannelEnabled("signal", channels)) {
+    tasks.push(
+      (async () => {
+        try {
+          const r = await searchSignal(runtime, query);
+          allHits.push(...r.hits);
+          unsupported.push(...r.unsupported);
+        } catch (err) {
+          degraded.push({
+            channel: "signal",
+            reason: `Signal search failed: ${err instanceof Error ? err.message : String(err)}`
+          });
+        }
+      })()
+    );
+  }
+  if (isChannelEnabled("whatsapp", channels)) {
+    tasks.push(
+      (async () => {
+        try {
+          const r = await searchWhatsApp(runtime, query);
+          allHits.push(...r.hits);
+          unsupported.push(...r.unsupported);
+        } catch (err) {
+          degraded.push({
+            channel: "whatsapp",
+            reason: `WhatsApp search failed: ${err instanceof Error ? err.message : String(err)}`
+          });
+        }
+      })()
+    );
+  }
+  if (isChannelEnabled("calendar", channels)) {
+    tasks.push(
+      (async () => {
+        try {
+          const r = await searchCalendar(runtime, query);
+          allHits.push(...r.hits);
+          unsupported.push(...r.unsupported);
+        } catch (err) {
+          degraded.push({
+            channel: "calendar",
+            reason: `Calendar search failed: ${err instanceof Error ? err.message : String(err)}`
+          });
+        }
+      })()
+    );
+  }
+  if (isChannelEnabled("x", channels)) {
+    tasks.push(
+      (async () => {
+        try {
+          const r = await searchXPostsChannel(runtime, query);
+          allHits.push(...r.hits);
+          unsupported.push(...r.unsupported);
+        } catch (err) {
+          degraded.push({
+            channel: "x",
+            reason: `X post search failed: ${err instanceof Error ? err.message : String(err)}`
+          });
+        }
+      })()
+    );
+  }
+  if (isChannelEnabled("x-dm", channels)) {
+    tasks.push(
+      (async () => {
+        try {
+          const r = await searchXDms(runtime, query);
+          allHits.push(...r.hits);
+          unsupported.push(...r.unsupported);
+        } catch (err) {
+          degraded.push({
+            channel: "x-dm",
+            reason: `X DM 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);
+  for (const entry of CONNECTORS_WITHOUT_NATIVE_SEARCH) {
+    if (channels?.includes(entry.channel)) {
+      unsupported.push(entry);
+    }
+  }
+  const merged = rankHits(dedupeHits(allHits));
+  const channelsWithHits = Array.from(
+    new Set(merged.map((h) => h.channel))
+  );
+  const finalLimit = (query.limit ?? DEFAULT_PER_CHANNEL_LIMIT) * CROSS_CHANNEL_SEARCH_CHANNELS.length;
+  const limited = merged.slice(0, finalLimit);
+  logger.debug(
+    `[cross-channel-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
+  };
+}
+export {
+  CROSS_CHANNEL_SEARCH_CHANNELS,
+  runCrossChannelSearch
+};
+//# sourceMappingURL=cross-channel-search.js.map