@vellumai/assistant 0.9.0 → 0.10.0-staging.2

package/src/contacts/contact-store.ts

@@ -1,12 +1,14 @@
 import { and, asc, desc, eq, isNotNull, like, sql } from "drizzle-orm";
 import { v4 as uuid } from "uuid";
 
+import type { ChannelId } from "../channels/types.js";
 import { getDb } from "../memory/db-connection.js";
 import {
   assistantContactMetadata,
   contactChannels,
   contacts,
 } from "../memory/schema.js";
+import { canonicalizeInboundIdentity } from "../util/canonicalize-identity.js";
 import { emitContactChange } from "./contact-events.js";
 import type {
   AssistantContactMetadata,
@@ -27,6 +29,27 @@ function escapeLike(value: string): string {
   return value.replace(/%/g, "").replace(/_/g, "");
 }
 
+/**
+ * Find the first contact_channels row whose (type, address) matches.
+ * Uses COLLATE NOCASE to find legacy lowercased rows (pre-migration 290).
+ */
+function findConflictingChannel(
+  db: ReturnType<typeof getDb>,
+  type: string,
+  address: string,
+) {
+  return db
+    .select()
+    .from(contactChannels)
+    .where(
+      and(
+        eq(contactChannels.type, type),
+        sql`${contactChannels.address} = ${address} COLLATE NOCASE`,
+      ),
+    )
+    .get();
+}
+
 /**
  * Pure slug transform applied to a display name. No DB lookup, no collision
  * handling — callers that need a collision-free filename should use
@@ -93,7 +116,6 @@ function parseChannel(
     type: row.type,
     address: row.address,
     isPrimary: row.isPrimary,
-    externalUserId: row.externalUserId,
     externalChatId: row.externalChatId,
     status: row.status as ContactChannel["status"],
     policy: row.policy as ContactChannel["policy"],
@@ -139,7 +161,6 @@ interface SyncChannelData {
   type: string;
   address: string;
   isPrimary?: boolean;
-  externalUserId?: string | null;
   externalChatId?: string | null;
   status?: ChannelStatus;
   policy?: ChannelPolicy;
@@ -152,15 +173,7 @@ interface SyncChannelData {
 
 // ── CRUD ─────────────────────────────────────────────────────────────
 
-/** Retrieve a contact by ID.
- * Used by functions that have already resolved identity through channel lookups. */
-export function getContactInternal(id: string): ContactWithChannels | null {
-  const db = getDb();
-  const row = db.select().from(contacts).where(eq(contacts.id, id)).get();
-  if (!row) return null;
-  return withChannels(parseContact(row));
-}
-
+/** Retrieve a contact by ID. */
 export function getContact(id: string): ContactWithChannels | null {
   const db = getDb();
   const row = db.select().from(contacts).where(eq(contacts.id, id)).get();
@@ -168,6 +181,9 @@ export function getContact(id: string): ContactWithChannels | null {
   return withChannels(parseContact(row));
 }
 
+/** @deprecated Use {@link getContact} directly. */
+export const getContactInternal = getContact;
+
 /**
  * Look up a single contact channel by its primary key.
  * Returns the parsed channel row, or null if it does not exist.
@@ -199,6 +215,15 @@ export function upsertContact(params: {
   const db = getDb();
   const now = Date.now();
 
+  // Canonicalize all channel addresses up front so every downstream path
+  // (lookups, inserts, conflict checks) uses the canonical form.
+  const canonicalChannels = params.channels?.map((ch) => ({
+    ...ch,
+    address:
+      canonicalizeInboundIdentity(ch.type as ChannelId, ch.address) ??
+      ch.address,
+  }));
+
   let contactId = params.id;
 
   // If an ID is provided, check if the contact exists for update
@@ -226,10 +251,10 @@ export function upsertContact(params: {
         .where(eq(contacts.id, contactId))
         .run();
 
-      if (params.channels) {
+      if (canonicalChannels) {
         syncChannels(
           contactId,
-          params.channels,
+          canonicalChannels,
           now,
           params.reassignConflictingChannels,
         );
@@ -240,20 +265,10 @@ export function upsertContact(params: {
     }
   }
 
-  // Try to find by channel address to avoid duplicates
-  if (!contactId && params.channels && params.channels.length > 0) {
-    for (const ch of params.channels) {
-      // Primary lookup: match by (type, address)
-      const existingChannel = db
-        .select()
-        .from(contactChannels)
-        .where(
-          and(
-            eq(contactChannels.type, ch.type),
-            eq(contactChannels.address, ch.address.toLowerCase()),
-          ),
-        )
-        .get();
+  // Try to find by channel canonical identity to avoid duplicates
+  if (!contactId && canonicalChannels && canonicalChannels.length > 0) {
+    for (const ch of canonicalChannels) {
+      const existingChannel = findConflictingChannel(db, ch.type, ch.address);
 
       if (existingChannel) {
         contactId = existingChannel.contactId;
@@ -274,7 +289,7 @@ export function upsertContact(params: {
           .where(eq(contacts.id, contactId))
           .run();
 
-        syncChannels(contactId, params.channels, now);
+        syncChannels(contactId, canonicalChannels, now);
         emitContactChange();
         return { ...getContactInternal(contactId)!, created: false };
       }
@@ -318,10 +333,10 @@ export function upsertContact(params: {
     })
     .run();
 
-  if (params.channels) {
+  if (canonicalChannels) {
     syncChannels(
       contactId,
-      params.channels,
+      canonicalChannels,
       now,
       params.reassignConflictingChannels,
     );
@@ -345,9 +360,8 @@ function syncChannels(
   const db = getDb();
 
   for (const ch of channels) {
-    const normalizedAddress = ch.address.toLowerCase();
-
-    // Check if this channel already exists for this contact
+    // Match by (type, address) — the canonical identity for all channel types.
+    // COLLATE NOCASE catches legacy rows that were lowercased by old write paths.
     const existing = db
       .select()
       .from(contactChannels)
@@ -355,7 +369,7 @@ function syncChannels(
         and(
           eq(contactChannels.contactId, contactId),
           eq(contactChannels.type, ch.type),
-          eq(contactChannels.address, normalizedAddress),
+          sql`${contactChannels.address} = ${ch.address} COLLATE NOCASE`,
         ),
       )
       .get();
@@ -367,9 +381,9 @@ function syncChannels(
       const isBlocked = existing.status === "blocked";
 
       const updateSet: Record<string, unknown> = {};
+      // Self-heal legacy lowercased addresses to canonical form.
+      if (existing.address !== ch.address) updateSet.address = ch.address;
       if (ch.isPrimary !== undefined) updateSet.isPrimary = ch.isPrimary;
-      if (ch.externalUserId !== undefined)
-        updateSet.externalUserId = ch.externalUserId;
       if (ch.externalChatId !== undefined)
         updateSet.externalChatId = ch.externalChatId;
       if (!isBlocked) {
@@ -394,17 +408,8 @@ function syncChannels(
       continue;
     }
 
-    // Check if this channel exists for a different contact (unique constraint)
-    const conflicting = db
-      .select()
-      .from(contactChannels)
-      .where(
-        and(
-          eq(contactChannels.type, ch.type),
-          eq(contactChannels.address, normalizedAddress),
-        ),
-      )
-      .get();
+    // Check if this channel's canonical identity conflicts with another contact.
+    const conflicting = findConflictingChannel(db, ch.type, ch.address);
 
     if (conflicting) {
       if (reassignConflicting) {
@@ -419,8 +424,6 @@ function syncChannels(
           contactId,
           updatedAt: now,
         };
-        if (ch.externalUserId !== undefined)
-          reassignSet.externalUserId = ch.externalUserId;
         if (ch.externalChatId !== undefined)
           reassignSet.externalChatId = ch.externalChatId;
         if (!isBlocked) {
@@ -451,9 +454,8 @@ function syncChannels(
         id: uuid(),
         contactId,
         type: ch.type,
-        address: normalizedAddress,
+        address: ch.address,
         isPrimary: ch.isPrimary ?? false,
-        externalUserId: ch.externalUserId ?? null,
         externalChatId: ch.externalChatId ?? null,
         status: ch.status ?? "unverified",
         policy: ch.policy ?? "allow",
@@ -480,8 +482,8 @@ export function searchContacts(params: {
 
   // Search by channel address first (exact or partial match)
   if (params.channelAddress) {
-    const normalizedAddress = escapeLike(params.channelAddress.toLowerCase());
-    if (!normalizedAddress) return [];
+    const escapedAddress = escapeLike(params.channelAddress);
+    if (!escapedAddress) return [];
     const channelRows = db
       .select({ contactId: contactChannels.contactId })
       .from(contactChannels)
@@ -490,9 +492,9 @@ export function searchContacts(params: {
         params.channelType
           ? and(
               eq(contactChannels.type, params.channelType),
-              like(contactChannels.address, `%${normalizedAddress}%`),
+              like(contactChannels.address, `%${escapedAddress}%`),
             )
-          : and(like(contactChannels.address, `%${normalizedAddress}%`)),
+          : and(like(contactChannels.address, `%${escapedAddress}%`)),
       )
       .all();
 
@@ -675,6 +677,8 @@ export function mergeContacts(
       .all();
 
     for (const ch of donorChannels) {
+      // COLLATE NOCASE catches legacy lowercased rows so we don't try to
+      // move a donor channel that collides with an existing survivor channel.
       const exists = tx
         .select()
         .from(contactChannels)
@@ -682,7 +686,7 @@ export function mergeContacts(
           and(
             eq(contactChannels.contactId, keepId),
             eq(contactChannels.type, ch.type),
-            eq(contactChannels.address, ch.address),
+            sql`${contactChannels.address} = ${ch.address} COLLATE NOCASE`,
           ),
         )
         .get();
@@ -705,11 +709,15 @@ export function mergeContacts(
 
 /**
  * Find a contact by a specific channel address. Returns null if not found.
+ * Canonicalizes the address before querying. Uses COLLATE NOCASE to match
+ * legacy lowercased rows that migration 290 couldn't restore.
  */
 export function findContactByAddress(
   type: string,
   address: string,
 ): ContactWithChannels | null {
+  const canonical =
+    canonicalizeInboundIdentity(type as ChannelId, address) ?? address;
   const db = getDb();
   const channel = db
     .select()
@@ -717,31 +725,7 @@ export function findContactByAddress(
     .where(
       and(
         eq(contactChannels.type, type),
-        eq(contactChannels.address, address.toLowerCase()),
-      ),
-    )
-    .get();
-
-  if (!channel) return null;
-  return getContactInternal(channel.contactId);
-}
-
-/**
- * Find a contact by channel external user ID. This is the key lookup for trust
- * resolution — maps a channel-native sender identity to its parent Contact.
- */
-export function findContactByChannelExternalId(
-  channelType: string,
-  externalUserId: string,
-): ContactWithChannels | null {
-  const db = getDb();
-  const channel = db
-    .select()
-    .from(contactChannels)
-    .where(
-      and(
-        eq(contactChannels.type, channelType),
-        eq(contactChannels.externalUserId, externalUserId),
+        sql`${contactChannels.address} = ${canonical} COLLATE NOCASE`,
       ),
     )
     .get();
@@ -751,8 +735,9 @@ export function findContactByChannelExternalId(
 }
 
 /**
- * Find a contact by channel external chat ID. This is the fallback lookup path
- * when externalUserId is not available — matches by (type, externalChatId).
+ * Find a contact by channel external chat ID. Fallback for callers that only
+ * have a chat ID (no user-level address) — matches by (type, externalChatId).
+ * No unique constraint exists on externalChatId, so ORDER BY is needed.
  */
 function findContactByChannelExternalChatId(
   channelType: string,
@@ -768,30 +753,40 @@ function findContactByChannelExternalChatId(
         eq(contactChannels.externalChatId, externalChatId),
       ),
     )
+    .orderBy(
+      sql`CASE ${contactChannels.status}
+        WHEN 'active' THEN 0
+        WHEN 'unverified' THEN 1
+        ELSE 2
+      END`,
+      desc(contactChannels.updatedAt),
+    )
     .get();
   if (!channel) return null;
   return getContactInternal(channel.contactId);
 }
 
 /**
- * Find a contact and matching channel by trying externalUserId first, then
+ * Find a contact and matching channel by trying address first, then
  * falling back to externalChatId. Mirrors the findMember lookup strategy.
  */
 export function findContactChannel(params: {
   channelType: string;
-  externalUserId?: string;
+  address?: string;
   externalChatId?: string;
 }): { contact: ContactWithChannels; channel: ContactChannel } | null {
-  if (params.externalUserId) {
-    const contact = findContactByChannelExternalId(
-      params.channelType,
-      params.externalUserId,
-    );
+  if (params.address) {
+    const canonical =
+      canonicalizeInboundIdentity(
+        params.channelType as ChannelId,
+        params.address,
+      ) ?? params.address;
+    const contact = findContactByAddress(params.channelType, canonical);
     if (contact) {
       const ch = contact.channels.find(
         (c) =>
           c.type === params.channelType &&
-          c.externalUserId === params.externalUserId,
+          c.address.toLowerCase() === canonical.toLowerCase(),
       );
       if (ch) return { contact, channel: ch };
     }
@@ -952,8 +947,6 @@ export function updateContactPrincipalAndChannel(
 ): boolean {
   const db = getDb();
   const now = Date.now();
-  const normalizedAddress = newPrincipalId.toLowerCase();
-
   // Look up the channel we're about to update so we know its type.
   const channel = db
     .select()
@@ -962,17 +955,8 @@ export function updateContactPrincipalAndChannel(
     .get();
   if (!channel) return false;
 
-  // Guard: check if another channel row already holds this (type, address).
-  const conflicting = db
-    .select()
-    .from(contactChannels)
-    .where(
-      and(
-        eq(contactChannels.type, channel.type),
-        eq(contactChannels.address, normalizedAddress),
-      ),
-    )
-    .get();
+  // Guard: check if another channel row holds this canonical identity.
+  const conflicting = findConflictingChannel(db, channel.type, newPrincipalId);
 
   if (conflicting && conflicting.id !== channelId) {
     return false;
@@ -986,8 +970,7 @@ export function updateContactPrincipalAndChannel(
 
     db.update(contactChannels)
       .set({
-        externalUserId: newPrincipalId,
-        address: normalizedAddress,
+        address: newPrincipalId,
         updatedAt: now,
       })
       .where(eq(contactChannels.id, channelId))

package/src/contacts/contacts-write.ts

@@ -6,8 +6,6 @@
  * identity and access-control state.
  */
 
-import type { ChannelId } from "../channels/types.js";
-import { canonicalizeInboundIdentity } from "../util/canonicalize-identity.js";
 import { emitContactChange } from "./contact-events.js";
 import {
   findContactChannel,
@@ -25,7 +23,6 @@ import type {
   ContactWriteResult,
 } from "./types.js";
 
-
 // ── Guardian operations ──────────────────────────────────────────────
 
 /**
@@ -68,12 +65,7 @@ export function upsertContactChannel(params: {
   let address: string;
 
   if (params.externalUserId) {
-    const canonical =
-      canonicalizeInboundIdentity(
-        params.sourceChannel as ChannelId,
-        params.externalUserId,
-      ) ?? params.externalUserId;
-    address = canonical;
+    address = params.externalUserId;
   } else if (params.externalChatId) {
     address = params.externalChatId;
   } else {
@@ -81,11 +73,11 @@ export function upsertContactChannel(params: {
     return null;
   }
 
-  let displayName = params.displayName ?? params.externalUserId ?? "Unknown";
+  let displayName = params.displayName ?? address;
 
   // When binding a channel to a specific contact (invite redemption), preserve
-  // the target contact's curated displayName (e.g. "Mom") instead of overwriting
-  // it with the redeemer's externalUserId.
+  // the target contact's curated displayName instead of overwriting it
+  // with the raw platform identity.
   if (params.contactId) {
     const targetContact = getContact(params.contactId);
     if (targetContact?.displayName?.trim().length) {
@@ -93,13 +85,6 @@ export function upsertContactChannel(params: {
     }
   }
 
-  const canonicalId = params.externalUserId
-    ? (canonicalizeInboundIdentity(
-        params.sourceChannel as ChannelId,
-        params.externalUserId,
-      ) ?? params.externalUserId)
-    : null;
-
   upsertContact({
     id: params.contactId,
     displayName,
@@ -108,7 +93,6 @@ export function upsertContactChannel(params: {
       {
         type: params.sourceChannel,
         address,
-        externalUserId: canonicalId,
         externalChatId: params.externalChatId ?? null,
         status: (params.status as ChannelStatus) ?? undefined,
         policy: (params.policy as ChannelPolicy) ?? undefined,
@@ -133,7 +117,7 @@ export function upsertContactChannel(params: {
 
   const contactResult = findContactChannel({
     channelType: params.sourceChannel,
-    externalUserId: canonicalId ?? undefined,
+    address,
     externalChatId: params.externalChatId,
   });
 
@@ -174,4 +158,3 @@ export function revokeMember(
   emitContactChange();
   return { contact, channel: updatedChannel };
 }
-

package/src/contacts/types.ts

@@ -62,7 +62,6 @@ export interface ContactChannel {
   type: string; // 'email' | 'slack' | 'whatsapp' | 'phone' | etc.
   address: string;
   isPrimary: boolean;
-  externalUserId: string | null;
   externalChatId: string | null;
   status: ChannelStatus;
   policy: ChannelPolicy;

package/src/context/compactor.ts

@@ -37,10 +37,8 @@ import type {
   ProviderResponse,
   ToolDefinition,
 } from "../providers/types.js";
-import {
-  isUntrustedTrustClass,
-  type TrustClass,
-} from "../runtime/actor-trust-resolver.js";
+import { type TrustClass } from "../runtime/actor-trust-resolver.js";
+import { resolveCapabilities } from "../runtime/capabilities.js";
 import { getLogger } from "../util/logger.js";
 import { stripInjectionsForCompaction } from "./strip-injections.js";
 import {
@@ -387,7 +385,7 @@ export function collectImageManifest(
   actorTrustClass?: TrustClass,
 ): ManifestEntry[] {
   const allRows = getMessages(conversationId);
-  const rows = isUntrustedTrustClass(actorTrustClass)
+  const rows = !resolveCapabilities(actorTrustClass).canAccessMemory
     ? filterMessagesForUntrustedActor(allRows)
     : allRows;
   const entries: ManifestEntry[] = [];
@@ -847,6 +845,69 @@ function buildCompactionRequest(
   return [...stripHistoricalWebSearchResults(history).messages, instruction];
 }
 
+// Token headroom a compaction summary call reserves on top of its history: room
+// for the instruction message and the summary the model emits, so a request
+// front-truncated to `compactionPrefixBudget` still fits the context window.
+const COMPACTION_INSTRUCTION_TOKEN_RESERVE = 800;
+const COMPACTION_OUTPUT_BUDGET_RATIO = 0.15;
+
+// Largest history (in estimated tokens) a compaction summary call may carry
+// while leaving room for the instruction and the emitted summary within
+// `maxInputTokens`.
+function compactionPrefixBudget(maxInputTokens: number): number {
+  return (
+    maxInputTokens -
+    COMPACTION_INSTRUCTION_TOKEN_RESERVE -
+    Math.floor(maxInputTokens * COMPACTION_OUTPUT_BUDGET_RATIO)
+  );
+}
+
+// Front-truncate the history handed to a compaction summary call so the call
+// itself fits the context window. Drops messages from the front until the
+// estimated prompt fits `budgetTokens`, then prepends a marker noting how many
+// were dropped so the model knows the summary covers only the visible portion.
+// Returns the input untouched when it already fits or holds a single message —
+// so a below-budget call keeps its prefix byte-aligned with the agent's warm
+// cache and pays no extra cache write.
+function truncateHistoryToBudget(args: {
+  messages: Message[];
+  systemPrompt: string;
+  budgetTokens: number;
+  providerName: string;
+}): Message[] {
+  const { messages, systemPrompt, budgetTokens, providerName } = args;
+  let estimate = estimatePromptTokens(messages, systemPrompt, { providerName });
+  if (estimate <= budgetTokens || messages.length <= 1) {
+    return messages;
+  }
+  let dropCount = 0;
+  while (estimate > budgetTokens && dropCount < messages.length - 1) {
+    dropCount++;
+    estimate = estimatePromptTokens(messages.slice(dropCount), systemPrompt, {
+      providerName,
+    });
+  }
+  if (dropCount === 0) {
+    return messages;
+  }
+  log.info(
+    { dropCount, budgetTokens, totalMessages: messages.length },
+    "Compaction summary input exceeds context window — truncating from front",
+  );
+  return [
+    {
+      role: "user" as const,
+      content: [
+        {
+          type: "text" as const,
+          text: `[${dropCount} earlier messages truncated — summary covers only the visible portion]`,
+        },
+      ],
+    },
+    ...messages.slice(dropCount),
+  ];
+}
+
 export async function runAssistantDrivenCompaction(
   args: CompactionRunArgs,
 ): Promise<CompactionRunResult> {
@@ -881,7 +942,19 @@ export async function runAssistantDrivenCompaction(
     args.targetTokens,
   );
 
-  const requestMessages = buildCompactionRequest(args.messages, instruction);
+  // Bound the summary call's own input to the context window. With no tool
+  // pair to anchor an emergency split, an overflow recovery routes the full
+  // history straight here, so the summary call must front-truncate itself or
+  // it overflows in turn. `args.messages` stays intact for tail resolution
+  // below — only the outbound request is truncated. A below-budget history is
+  // returned untouched, keeping the prefix aligned with the agent's warm cache.
+  const summaryHistory = truncateHistoryToBudget({
+    messages: args.messages,
+    systemPrompt: args.systemPrompt,
+    budgetTokens: compactionPrefixBudget(args.maxInputTokens),
+    providerName: args.provider.tokenEstimationProvider ?? args.provider.name,
+  });
+  const requestMessages = buildCompactionRequest(summaryHistory, instruction);
 
   let response: ProviderResponse;
   try {
@@ -1132,8 +1205,8 @@ export async function runAssistantDrivenCompaction(
   // from the moment of capture — keeping them would (a) waste tokens on
   // outdated content, (b) duplicate against the freshly re-injected blocks
   // the next turn produces, and (c) leak `<system_reminder>` text the model
-  // is not supposed to see in history. `<turn_context>` and `<workspace>`
-  // are intentionally preserved by `RUNTIME_INJECTION_PREFIXES`.
+  // is not supposed to see in history. `<turn_context>` is intentionally
+  // preserved by `RUNTIME_INJECTION_PREFIXES`.
   const tailMessages = stripInjectionsForCompaction(
     args.messages.slice(tailIndex),
   );
@@ -1296,55 +1369,16 @@ export async function runEmergencyCompaction(
   const keptTail = stripInjectionsForCompaction(
     args.messages.slice(splitIndex),
   );
-  let prefix = args.messages.slice(0, splitIndex);
-
-  // If the prefix itself exceeds the context window, truncate messages
-  // from the front so the model can at least see the recent portion.
-  // Reserve budget for the instruction message + output.
-  const instructionBudget = 800; // ~tokens for the emergency prompt
-  const outputBudget = Math.floor(args.maxInputTokens * 0.15);
-  const prefixBudget = args.maxInputTokens - instructionBudget - outputBudget;
-
-  let prefixEstimate = estimatePromptTokens(prefix, args.systemPrompt, {
+  // Bound the prefix to the context window so the summary call fits, reserving
+  // budget for the instruction message and the emitted summary. Truncates from
+  // the front, keeping the recent portion the summary most needs.
+  const prefix = truncateHistoryToBudget({
+    messages: args.messages.slice(0, splitIndex),
+    systemPrompt: args.systemPrompt,
+    budgetTokens: compactionPrefixBudget(args.maxInputTokens),
     providerName: args.provider.tokenEstimationProvider ?? args.provider.name,
   });
 
-  if (prefixEstimate > prefixBudget && prefix.length > 1) {
-    log.info(
-      {
-        prefixEstimate,
-        prefixBudget,
-        prefixMessages: prefix.length,
-      },
-      "Emergency compaction: prefix exceeds context window — truncating from front",
-    );
-    // Drop messages from the front until we fit. Keep at least the first
-    // message (may be an existing summary) and try to preserve recent context.
-    let dropCount = 0;
-    while (prefixEstimate > prefixBudget && dropCount < prefix.length - 1) {
-      dropCount++;
-      const truncated = prefix.slice(dropCount);
-      prefixEstimate = estimatePromptTokens(truncated, args.systemPrompt, {
-        providerName:
-          args.provider.tokenEstimationProvider ?? args.provider.name,
-      });
-    }
-    if (dropCount > 0) {
-      prefix = [
-        {
-          role: "user" as const,
-          content: [
-            {
-              type: "text" as const,
-              text: `[${dropCount} earlier messages truncated — summary covers only the visible portion]`,
-            },
-          ],
-        },
-        ...prefix.slice(dropCount),
-      ];
-    }
-  }
-
   const instruction: Message = {
     role: "user",
     content: [{ type: "text", text: EMERGENCY_COMPACTION_PROMPT }],