@k2b/cloud 0.39.0 → 0.41.0

package/src/ai/open-questions.ts

@@ -0,0 +1,172 @@
+import { sql } from "bun";
+import { z } from "zod";
+import { APPROVALS_PAGE_SIZE } from "../contracts/approvals";
+import {
+  CapabilityActionCallReviewSchema,
+  CapabilityActionReviewDataSchema,
+  CapabilitySemanticLinkSchema,
+} from "../contracts/capabilities";
+import { openRequests } from "../services/approvals/list";
+import { logger } from "../services/logging";
+import { reviewShortText, toolActionCard, toolBlockReview } from "./chat/action-card";
+import { aiToolIcon } from "./chat/message-utils";
+import { legacyOutcomeWords } from "./chat/tool-action-words";
+import { type AiTurnBlock, toolBlockId } from "./protocol";
+
+export type AiOpenQuestion = {
+  /** The approval request id (approvals.requests.id). */
+  id: string;
+  /** Short id of the chat the question waits in. */
+  conversationId: string;
+  /** The chat's current title, at most 200 code points; chat content, never Cloud's words. */
+  conversationTitle: string | null;
+  /** The question's data-chat-anchor: the id of the tool block the chat renders it in. */
+  anchor: string;
+  /** The question's short form, plain text, at most 160 code points. */
+  short: string;
+  /** The app the question is about, as the card shows it. */
+  app: { name: string; icon: string; accent?: string };
+  createdAt: string;
+};
+
+export type AiOpenQuestions = {
+  items: AiOpenQuestion[];
+  /** All open questions of the person, across pages. */
+  count: number;
+};
+
+type QuestionRow = {
+  id: string;
+  conversationId: string;
+  conversationTitle: string | null;
+  displayCallId: string;
+  appId: string;
+  sentence: string;
+  toolName: string;
+  createdAt: Date;
+  block: Extract<AiTurnBlock, { kind: "tool" }> | null;
+};
+
+const log = logger("ai:open-questions");
+const legacyReviewSchema = z.object({
+  question: z.string().min(1),
+  rows: z.array(z.object({ label: z.string(), value: z.string(), format: z.enum(["date", "date-time"]).optional() })),
+  markdown: z.string().optional(),
+  summary: z.string().optional(),
+  links: z.array(CapabilitySemanticLinkSchema).optional(),
+});
+
+const ownedRequests = (ownerUserId: string) => sql`
+  SELECT r.* FROM (${openRequests(ownerUserId)}) r
+  WHERE EXISTS (
+    SELECT 1 FROM ai.pending_actions p JOIN ai.conversations c ON c.id=p.conversation_id
+    WHERE p.approval_id=r.id AND p.status='pending' AND p.kind IN ('approval','custom_approval')
+      AND c.created_by_user_id=${ownerUserId}::uuid
+  )`;
+
+/** One bounded, owner-scoped snapshot, using exactly the chat's stored question card. */
+export const listAiOpenQuestions = async (input: { ownerUserId: string; locale: string; timeZone: string }): Promise<AiOpenQuestions> => {
+  const [counts] = await sql<{ count: number }[]>`
+    SELECT count(*)::int AS count FROM (${ownedRequests(input.ownerUserId)}) r`;
+  const rows = await sql<QuestionRow[]>`
+    WITH page AS (
+      SELECT * FROM (${ownedRequests(input.ownerUserId)}) r
+      ORDER BY r.created_at DESC, r.id DESC LIMIT ${APPROVALS_PAGE_SIZE}
+    )
+    SELECT r.id, r.app_id AS "appId", r.sentence, r.created_at AS "createdAt",
+      question.short_id AS "conversationId", question.title AS "conversationTitle",
+      question.display_call_id AS "displayCallId", question.tool_name AS "toolName", question.block
+    FROM page r JOIN LATERAL (
+      SELECT c.short_id, c.title, p.tool_name,
+        CASE WHEN p.kind='custom_approval'
+          THEN COALESCE(substring(p.call_id FROM '^(.*)-approval-[0-9]+$'), p.call_id)
+          ELSE p.call_id END AS display_call_id,
+        (SELECT block FROM jsonb_array_elements(
+          CASE WHEN jsonb_typeof(t.live_blocks)='array' THEN t.live_blocks ELSE '[]'::jsonb END
+        ) AS blocks(block)
+          WHERE block->>'kind'='tool' AND block->>'callId'=p.call_id LIMIT 1) AS block
+      FROM ai.pending_actions p JOIN ai.conversations c ON c.id=p.conversation_id
+        JOIN ai.turns t ON t.id=p.turn_id
+      WHERE p.approval_id=r.id AND p.status='pending' AND p.kind IN ('approval','custom_approval')
+        AND c.created_by_user_id=${input.ownerUserId}::uuid
+      ORDER BY p.created_at DESC, p.id DESC LIMIT 1
+    ) question ON true
+    ORDER BY r.created_at DESC, r.id DESC`;
+
+  return {
+    count: counts?.count ?? 0,
+    items: rows.map((row) => openQuestionFromRow(row, input)),
+  };
+};
+
+/** Stop at the payload bound without splitting a Unicode code point or copying the rest of a legacy message. */
+const boundedText = (text: string, max: number): string => {
+  const points: string[] = [];
+  for (const point of text) {
+    if (points.length === max) return `${points.slice(0, max - 1).join("")}…`;
+    points.push(point);
+  }
+  return text;
+};
+
+/** Present one stored question without database access. */
+export const openQuestionFromRow = (row: QuestionRow, input: { locale: string; timeZone: string }): AiOpenQuestion => {
+  const block = row.block;
+  const presentation = block?.presentation;
+  const question: AiOpenQuestion = {
+    id: row.id,
+    conversationId: row.conversationId,
+    conversationTitle: row.conversationTitle === null ? null : boundedText(row.conversationTitle, 200),
+    // The id the chat renders the card under: a custom approval's card carries its parent call, also when a stored
+    // block still has the approval's own id (see normalizeCustomApprovalBlocks in client/projection.ts).
+    anchor: toolBlockId(row.displayCallId),
+    short: boundedText(row.sentence.split(/\r?\n/, 1)[0] ?? "", 160),
+    app: {
+      name: typeof presentation?.appName === "string" ? presentation.appName : block ? "Cloud" : row.appId,
+      icon: aiToolIcon(
+        typeof block?.name === "string" ? block.name : row.toolName,
+        typeof presentation?.appIcon === "string" ? presentation.appIcon : undefined,
+      ),
+      ...(typeof presentation?.appAccent === "string" ? { accent: presentation.appAccent } : {}),
+    },
+    createdAt: row.createdAt.toISOString(),
+  };
+  if (!block) return question;
+  try {
+    if (
+      typeof block.id !== "string" ||
+      !block.id ||
+      typeof block.name !== "string" ||
+      !block.name ||
+      typeof block.callId !== "string" ||
+      !["running", "awaiting_approval", "awaiting_client", "completed", "failed", "rejected"].includes(block.status)
+    )
+      throw new Error("Malformed tool block");
+    if (block.review == null && block.approval?.review != null) CapabilityActionReviewDataSchema.parse(block.approval.review);
+    const review = toolBlockReview(block);
+    if (review !== null) {
+      if ("legacy" in review) legacyReviewSchema.parse(review.legacy);
+      else CapabilityActionCallReviewSchema.parse(review);
+    }
+    const card = toolActionCard(block, {
+      locale: input.locale,
+      timeZone: input.timeZone,
+      outcome: legacyOutcomeWords(block, input.locale, input.timeZone),
+    });
+    const short =
+      review && !("legacy" in review)
+        ? reviewShortText(review, { locale: input.locale, timeZone: input.timeZone, app: card.app })
+        : card.questionText;
+    if (
+      typeof short !== "string" ||
+      typeof card.app.name !== "string" ||
+      typeof card.app.icon !== "string" ||
+      (card.app.accent !== undefined && typeof card.app.accent !== "string")
+    )
+      throw new Error("Malformed question card");
+    return { ...question, short: boundedText(short, 160), app: card.app };
+  } catch {
+    log.warn("Failed to present open question", { approvalId: row.id, conversationId: row.conversationId });
+    return question;
+  }
+};

package/src/ai/projects-routes.ts

@@ -4,6 +4,7 @@ import { getCapability } from "../_internal/registry";
 import { CloudResourceRefSchema, cloudResourceRefAppId, resolveCapabilityResourceReader } from "../contracts/capabilities";
 import { AuthenticatedPrincipalSchema } from "../contracts/shared";
 import { type AuthContext, auth, err, fail, getLocale, ok, rateLimit, respond, v } from "../server";
+import { noTransform } from "../server/middleware/no-transform";
 import { ImageMetadataError } from "../services/image-metadata";
 import { aiChatMessages } from "./chat/messages";
 import { decodeAiFileContent } from "./files-store";
@@ -71,6 +72,8 @@ type AiProjectsRouteDependencies = {
 
 const buildAiProjectsRoutes = (dependencies: AiProjectsRouteDependencies = {}) =>
   new Hono<AuthContext>()
+    // The list combines projects from separate grants; the writer of one can rename it next to another project's instructions.
+    .use("*", noTransform())
     .use(dependencies.limit ?? rateLimit())
     .use("*", dependencies.authenticate ?? auth.requireRole("authenticated"))
     .get("/", async (c) => respond(c, ok({ projects: (await aiProjects.list(c.get("accessSubject") ?? null)).map(publicProject) })))

package/src/ai/protocol.ts

@@ -1,5 +1,6 @@
 import type { CompactResult, InboundEvent, Message } from "@k2b/nessi";
-import type { CapabilityActionReview } from "../contracts/capabilities";
+import type { CapabilityActionReviewData } from "../contracts/capabilities";
+import type { AiActionCheck, AiStoredActionReview } from "./action-review";
 import type { AiConversation, AiFrontendToolMode, AiStoredMessage, AiToolPresentation, AiTurnStatus } from "./types";
 
 /**
@@ -48,7 +49,7 @@ export type AiTurnBlock =
       /** Present while status is awaiting_approval. */
       approval?: {
         message?: string;
-        review?: CapabilityActionReview;
+        review?: CapabilityActionReviewData;
         allowAlways: boolean;
         /** Whether the approval can be remembered for this chat. */
         allowChat?: boolean;
@@ -66,6 +67,13 @@ export type AiTurnBlock =
       presentation?: AiToolPresentation;
       /** Requests a website approval let through without asking, in order; shown whatever the call's outcome. */
       receipts?: { method: string; url: string }[];
+      /**
+       * The call's review as Cloud stored it when the app reviewed it. It stays after the decision, so the question,
+       * its receipt, and a reload all read the same sentence.
+       */
+      review?: AiStoredActionReview;
+      /** The app's `check` after an outcome Cloud could not see. */
+      check?: AiActionCheck;
     }
   | { id: string; kind: "compaction"; status: "running" | "completed" | "skipped" | "failed"; result?: CompactResult };
 
@@ -248,6 +256,8 @@ export const buildBlocksFromMessages = (
     meta?: {
       steerId?: string;
       toolPresentations?: Record<string, AiToolPresentation>;
+      toolReviews?: Record<string, AiStoredActionReview>;
+      toolChecks?: Record<string, AiActionCheck>;
       toolOutcomes?: Record<string, "rejected" | "approved" | "expired">;
       websiteReceipts?: Record<string, Record<string, { method: string; url: string }>>;
     } | null;
@@ -275,6 +285,8 @@ export const buildBlocksFromMessages = (
             args: block.args,
             status: "running",
             presentation: meta?.toolPresentations?.[block.id],
+            review: meta?.toolReviews?.[block.id],
+            check: meta?.toolChecks?.[block.id],
             // A turn that ended before an approved call returned records the approval on the call's message, and an
             // approval it left waiting as expired.
             ...(outcome === "approved" || outcome === "expired" ? { approved: outcome === "approved" } : {}),

package/src/ai/question-text.ts

@@ -0,0 +1,8 @@
+/**
+ * The plain-text form of an Assistant question, the same one the chat card shows: for `cld`, notifications, and Cloud
+ * Login. Pure and browser-safe, in its own entry so neither the CLI bundle nor browser bundles that use
+ * `@k2b/cloud/ai/browser` pull it in by accident.
+ */
+export { type ApprovalCardInput, approvalCard } from "../approvals/approval-card";
+export type { ActionCard } from "./chat/action-card";
+export { type ActionQuestionText, type ActionTextRow, actionCardText, actionQuestionLines } from "./chat/action-text";

package/src/ai/recent-resources.ts

@@ -0,0 +1,240 @@
+import { z } from "zod";
+import { resolveCapabilityManifestPresentation } from "../_internal/capabilities";
+import { listCapabilities } from "../_internal/registry";
+import { type CapabilityDispatchParams, dispatchCapability, QUERY_TIMEOUT_MS } from "../api/capabilities";
+import {
+  CloudResourceRefSchema,
+  capabilityResultSchema,
+  cloudResourceRefAppId,
+  LinkedCloudResourceReferenceSchema,
+  resolveCapabilityResourceReader,
+} from "../contracts/capabilities";
+import type { CapabilityRegistryEntry } from "../contracts/registry";
+import type { RequestAuthority } from "../server";
+import { resolveAppIdentityPresentation } from "../shared/app-presentation";
+import { LOCALE_HEADER } from "../shared/locale";
+import { CODE_SOURCE_TOOLS } from "./code-source-contracts";
+import { createCodeSourceTool } from "./code-source-tools";
+import { RECENT_SENT_REF_LIMIT } from "./recent-sent-refs";
+import { addCloudResourceHrefs } from "./resource-refs";
+import { aiSkills } from "./skills";
+import { aiConversations } from "./store";
+import type { AiConversationService, AiRecentResource } from "./types";
+
+export const AiRecentResourceSchema: z.ZodType<AiRecentResource> = z
+  .object({
+    ref: CloudResourceRefSchema,
+    title: LinkedCloudResourceReferenceSchema.shape.title.unwrap(),
+    icon: LinkedCloudResourceReferenceSchema.shape.icon,
+    href: LinkedCloudResourceReferenceSchema.shape.href,
+    kind: z.string().min(1).max(120),
+    preview: z.string().max(160).optional(),
+    appName: z.string().min(1).max(120),
+    count: z.number().int().positive(),
+  })
+  .strict();
+
+const ReaderResult = capabilityResultSchema(z.unknown(), { consumer: true });
+const StudioData = z.object({
+  id: z.string(),
+  title: LinkedCloudResourceReferenceSchema.shape.title.unwrap(),
+  icon: LinkedCloudResourceReferenceSchema.shape.icon,
+  description: z.string().optional(),
+});
+const studioReader = async (input: {
+  id: string;
+  conversationId: string;
+  authority: RequestAuthority;
+  locale: string;
+  signal: AbortSignal;
+}): Promise<unknown> => {
+  const tool = createCodeSourceTool("code_read");
+  if (tool.location !== "server") throw new Error("Studio reader must run on the server.");
+  return tool.run(CODE_SOURCE_TOOLS.code_read.input.parse({ id: input.id }), {
+    actor: input.authority.actor,
+    conversationId: input.conversationId,
+    locale: input.locale,
+    signal: input.signal,
+    requestApproval: async () => false,
+    requestClientTool: async () => {
+      throw new Error("Recent resources cannot call client tools.");
+    },
+  });
+};
+
+export type AiRecentResourceDependencies = {
+  store?: Pick<AiConversationService, "listRecentSentResourceRefs">;
+  listRegistry?: () => Promise<CapabilityRegistryEntry[]>;
+  dispatch?: (params: CapabilityDispatchParams) => Promise<Response>;
+  skills?: Pick<typeof aiSkills, "list">;
+  studioReader?: typeof studioReader;
+  timeoutMs?: number;
+};
+
+const german = (locale: string) => locale.toLowerCase().split("-")[0] === "de";
+/** Skills and Studio apps belong to the Assistant, which has no capability presentation to read its name from. */
+const assistantName = (locale: string) => (german(locale) ? "Assistent" : "Assistant");
+
+/** First line only; reserve one character for the ellipsis and avoid splitting words. */
+export const recentResourcePreview = (value: string | undefined): string | undefined => {
+  const line = value?.split(/\r\n?|\n/, 1)[0]?.trim();
+  if (!line) return undefined;
+  if (line.length <= 160) return line;
+  const clipped = line.slice(0, 159);
+  const boundary = clipped.search(/\s+\S*$/);
+  return `${(boundary > 0 ? clipped.slice(0, boundary) : clipped).trimEnd()}…`;
+};
+
+/** Enforce the shared budget even when a dependency ignores cancellation. */
+const withinBudget = async <T>(signal: AbortSignal, run: () => Promise<T>): Promise<T> => {
+  signal.throwIfAborted();
+  let abort: () => void = () => {};
+  const aborted = new Promise<never>((_, reject) => {
+    abort = () => reject(signal.reason);
+    signal.addEventListener("abort", abort, { once: true });
+  });
+  try {
+    return await Promise.race([run(), aborted]);
+  } finally {
+    signal.removeEventListener("abort", abort);
+  }
+};
+
+export const listAiRecentResources = async (input: {
+  ownerUserId: string;
+  authority: RequestAuthority;
+  locale: string;
+  signal: AbortSignal;
+  dependencies?: AiRecentResourceDependencies;
+}): Promise<AiRecentResource[]> => {
+  const deps = input.dependencies ?? {};
+  const signal = AbortSignal.any([input.signal, AbortSignal.timeout(deps.timeoutMs ?? QUERY_TIMEOUT_MS)]);
+  // Unreadable history is no answer, not an empty one: the request fails, so the browser asks again at its next opening.
+  const sent = await withinBudget(signal, () =>
+    (deps.store ?? aiConversations).listRecentSentResourceRefs({ ownerUserId: input.ownerUserId }),
+  );
+  if (!sent.length || signal.aborted) return [];
+  const candidates = sent.slice(0, RECENT_SENT_REF_LIMIT);
+  const skillIds = candidates.flatMap(({ ref }) => (ref.type === "core.ai.skill" ? [ref.id] : []));
+  // Exactly the sent Skills, so a large Skill catalog never pushes one out; failing, they are left out like a reader.
+  const skills = skillIds.length
+    ? withinBudget(signal, () => (deps.skills ?? aiSkills).list(input.authority.accessSubject, { shortIds: skillIds })).catch(() => [])
+    : Promise.resolve([]);
+  const registry = candidates.some(({ ref }) => ref.type !== "core.ai.skill" && ref.type !== "assistant.artifact")
+    ? withinBudget(signal, deps.listRegistry ?? listCapabilities).catch(() => [])
+    : Promise.resolve([]);
+  const resources = await Promise.all(
+    candidates.map(async (candidate): Promise<AiRecentResource | null> => {
+      try {
+        signal.throwIfAborted();
+        const { ref, count } = candidate;
+        if (ref.type === "core.ai.skill") {
+          const skill = (await skills).find((skill) => skill.shortId === ref.id && skill.enabled !== false);
+          if (!skill) return null;
+          return {
+            ref,
+            count,
+            title: skill.name.slice(0, 500),
+            icon: "ti ti-sparkles",
+            kind: "Skill",
+            preview: recentResourcePreview(skill.description),
+            appName: assistantName(input.locale),
+          };
+        }
+        if (ref.type === "assistant.artifact") {
+          const { actor, accessSubject, credentialKind, scopes } = input.authority;
+          // code_read reconstructs a user session authority. Only use it when that is
+          // exactly this request's authority; never widen scoped/delegated credentials.
+          if (
+            credentialKind !== "session" ||
+            scopes.length ||
+            actor.kind !== "user" ||
+            actor.delegation ||
+            actor.sessionKind === "app" ||
+            accessSubject.type !== "user" ||
+            accessSubject.userId !== actor.user.id
+          )
+            return null;
+          const answer = ReaderResult.parse(
+            await withinBudget(signal, () =>
+              (deps.studioReader ?? studioReader)({
+                id: ref.id,
+                conversationId: candidate.conversationId,
+                authority: input.authority,
+                locale: input.locale,
+                signal,
+              }),
+            ),
+          );
+          signal.throwIfAborted();
+          const data = StudioData.parse(answer.data);
+          if (data.id !== ref.id || !data.title.trim()) return null;
+          const matched = answer.refs?.find((entry) => entry.type === ref.type && entry.id === ref.id);
+          const ownRef = matched ? LinkedCloudResourceReferenceSchema.parse(matched) : undefined;
+          const href = ownRef?.href ?? answer.links?.find((link) => link.rel === "open")?.href;
+          return {
+            ref,
+            count,
+            title: data.title,
+            icon: ownRef?.icon ?? data.icon,
+            href,
+            preview: recentResourcePreview(ownRef?.preview ?? data.description),
+            kind: german(input.locale) ? "Studio-App" : "Studio app",
+            appName: assistantName(input.locale),
+          };
+        }
+        const apps = await registry;
+        signal.throwIfAborted();
+        const appId = cloudResourceRefAppId(ref);
+        const app = apps.find((app) => app.appId === appId);
+        const reader = app && resolveCapabilityResourceReader(app.manifest, ref);
+        if (!app || !reader) return null;
+        const response = await withinBudget(signal, () =>
+          (deps.dispatch ?? dispatchCapability)({
+            request: new Request("http://localhost/api/ai/resources/recent", {
+              method: "POST",
+              headers: { [LOCALE_HEADER]: input.locale, "x-request-id": crypto.randomUUID() },
+              signal,
+            }),
+            kind: "queries",
+            origin: "assistant",
+            appId: app.appId,
+            capabilityId: reader.localId,
+            input: { id: ref.id },
+            authority: input.authority,
+            locale: input.locale,
+          }),
+        );
+        if (!response.ok) return null;
+        const answer = ReaderResult.parse(addCloudResourceHrefs(await withinBudget(signal, () => response.json()), apps));
+        const matched = answer.refs?.find((entry) => entry.type === ref.type && entry.id === ref.id);
+        const ownRef = matched ? LinkedCloudResourceReferenceSchema.parse(matched) : undefined;
+        if (!ownRef?.title?.trim()) return null;
+        signal.throwIfAborted();
+        const manifest = resolveCapabilityManifestPresentation(app.manifest, app.presentation, input.locale);
+        const type = manifest.types.find((type) => `${app.appId}.${type.localId}` === ref.type);
+        if (!type) return null;
+        const presentation = resolveAppIdentityPresentation(
+          { name: app.appName, description: app.appDescription, presentation: app.appPresentation },
+          input.locale,
+        );
+        return {
+          ref,
+          count,
+          title: ownRef.title,
+          icon: (ownRef.icon ?? type.icon ?? app.appIcon)?.slice(0, 120),
+          href: ownRef.href,
+          kind: type.title.slice(0, 120),
+          preview: recentResourcePreview(ownRef.preview),
+          appName: presentation.name.slice(0, 120),
+        };
+      } catch {
+        return null;
+      }
+    }),
+  );
+  return resources.flatMap((resource) => {
+    const parsed = AiRecentResourceSchema.safeParse(resource);
+    return parsed.success ? [parsed.data] : [];
+  });
+};

package/src/ai/recent-sent-refs.ts

@@ -0,0 +1,38 @@
+import { parseAiResourceMarker } from "./resource-markers";
+import type { AiRecentSentResourceRef } from "./types";
+
+export const RECENT_SENT_REF_LIMIT = 8;
+// Look back 25 messages/conversations per displayed ref: useful sparse history without
+// scanning the owner's lifetime. insertMessageLocked (used by submitChatTurn and steering)
+// bumps conversation.updated_at, so newly sent turns enter this indexed window.
+export const RECENT_SENT_MESSAGE_SCAN_LIMIT = RECENT_SENT_REF_LIMIT * 25;
+export const RECENT_SENT_CONVERSATION_SCAN_LIMIT = RECENT_SENT_MESSAGE_SCAN_LIMIT;
+
+/**
+ * Rows arrive newest first and contain only marker text, never whole message bodies. Forking or copying a chat copies
+ * its messages with their short IDs, so a message ID counts once, however many chats hold a copy of it.
+ */
+export const collectRecentSentResourceRefs = (
+  messages: readonly { conversationId: string; messageId: string; lastSentAt: string; markers: readonly string[] }[],
+): AiRecentSentResourceRef[] => {
+  const refs = new Map<string, AiRecentSentResourceRef>();
+  const counted = new Set<string>();
+  for (const message of messages) {
+    if (counted.has(message.messageId)) continue;
+    counted.add(message.messageId);
+    const seen = new Set<string>();
+    for (const text of message.markers) {
+      const marker = parseAiResourceMarker(text);
+      if (!marker) continue;
+      const key = JSON.stringify([marker.ref.type, marker.ref.id]);
+      if (seen.has(key)) continue;
+      seen.add(key);
+      const existing = refs.get(key);
+      if (existing) existing.count++;
+      else if (refs.size < RECENT_SENT_REF_LIMIT) {
+        refs.set(key, { ref: marker.ref, count: 1, lastSentAt: message.lastSentAt, conversationId: message.conversationId });
+      }
+    }
+  }
+  return [...refs.values()];
+};