@axhub/genie 0.2.8 → 0.2.10

package/server/session-core/eventStore.js

@@ -1,37 +1,61 @@
+import fsSync from 'fs';
 import fs from 'fs/promises';
 import os from 'os';
 import path from 'path';
+import readline from 'readline';
 
 import {
   CONVERSATION_EVENT_KINDS,
   isConversationEvent
 } from '../../shared/conversationEvents.js';
 
-const MIRRORED_EVENT_STORE_ROOT = path.join(os.homedir(), '.axhub-genie', 'session-events');
+function getMirroredEventStoreRoot() {
+  if (process.env.AXHUB_GENIE_SESSION_EVENTS_ROOT) {
+    return path.resolve(process.env.AXHUB_GENIE_SESSION_EVENTS_ROOT);
+  }
+
+  return path.join(os.homedir(), '.axhub-genie', 'session-events');
+}
 const PERSISTED_EVENT_KINDS = new Set([
+  CONVERSATION_EVENT_KINDS.USER_MESSAGE,
+  CONVERSATION_EVENT_KINDS.ASSISTANT_TEXT_START,
+  CONVERSATION_EVENT_KINDS.ASSISTANT_TEXT_DELTA,
+  CONVERSATION_EVENT_KINDS.ASSISTANT_TEXT_END,
   CONVERSATION_EVENT_KINDS.SESSION_STATE_CHANGED,
   CONVERSATION_EVENT_KINDS.ERROR,
   CONVERSATION_EVENT_KINDS.APPROVAL_REQUEST,
   CONVERSATION_EVENT_KINDS.APPROVAL_RESOLVED,
-  CONVERSATION_EVENT_KINDS.SYSTEM_NOTICE
+  CONVERSATION_EVENT_KINDS.SYSTEM_NOTICE,
+  CONVERSATION_EVENT_KINDS.MODE_UPDATE,
+  CONVERSATION_EVENT_KINDS.AVAILABLE_COMMANDS_UPDATE,
+  CONVERSATION_EVENT_KINDS.CONFIG_OPTION_UPDATE,
+  CONVERSATION_EVENT_KINDS.SESSION_INFO_UPDATE,
+  CONVERSATION_EVENT_KINDS.USAGE_UPDATE,
+  CONVERSATION_EVENT_KINDS.PLAN_UPDATE,
+  CONVERSATION_EVENT_KINDS.ARTIFACT_CREATED
 ]);
 
 function getSessionEventFilePath(provider, sessionId) {
-  return path.join(MIRRORED_EVENT_STORE_ROOT, String(provider || 'claude'), `${sessionId}.jsonl`);
+  return path.join(getMirroredEventStoreRoot(), String(provider || 'claude'), `${sessionId}.jsonl`);
 }
 
 function normalizePersistedEvents(events = []) {
   return events.filter((event) => (
     isConversationEvent(event) &&
     event.sessionId &&
-    (
-      event.extensions?.runtimeSource === 'acp' ||
-      event.rawRef?.runtime === 'acp' ||
-      PERSISTED_EVENT_KINDS.has(event.kind)
-    )
+    PERSISTED_EVENT_KINDS.has(event.kind)
   ));
 }
 
+function extractSerializedEventKind(line) {
+  if (typeof line !== 'string' || !line) {
+    return null;
+  }
+
+  const match = line.match(/"kind"\s*:\s*"([^"]+)"/);
+  return match?.[1] || null;
+}
+
 function sortObjectKeys(value) {
   if (Array.isArray(value)) {
     return value.map(sortObjectKeys);
@@ -91,19 +115,35 @@ export async function readMirroredConversationEvents(provider, sessionId) {
   const filePath = getSessionEventFilePath(provider, sessionId);
 
   try {
-    const content = await fs.readFile(filePath, 'utf8');
-    return content
-      .split('\n')
-      .map((line) => line.trim())
-      .filter(Boolean)
-      .map((line) => {
-        try {
-          return JSON.parse(line);
-        } catch {
-          return null;
+    const fileStream = fsSync.createReadStream(filePath, { encoding: 'utf8' });
+    const rl = readline.createInterface({
+      input: fileStream,
+      crlfDelay: Infinity
+    });
+    const events = [];
+
+    for await (const rawLine of rl) {
+      const line = rawLine.trim();
+      if (!line) {
+        continue;
+      }
+
+      const kind = extractSerializedEventKind(line);
+      if (!kind || !PERSISTED_EVENT_KINDS.has(kind)) {
+        continue;
+      }
+
+      try {
+        const event = JSON.parse(line);
+        if (isConversationEvent(event) && PERSISTED_EVENT_KINDS.has(event.kind)) {
+          events.push(event);
         }
-      })
-      .filter(isConversationEvent);
+      } catch {
+        // Skip malformed lines and oversized legacy transcript events.
+      }
+    }
+
+    return events;
   } catch (error) {
     if (error?.code === 'ENOENT') {
       return [];

package/server/session-core/providerAdapters.js

@@ -14,12 +14,26 @@ import {
   findAcpSessionRecord,
   listAcpSessions
 } from '../acp-runtime/session-store.js';
+import { mergeSessionLists } from './sessionListMerge.js';
 
 async function flattenLegacyMessages(result) {
   if (Array.isArray(result)) return result;
   return Array.isArray(result?.messages) ? result.messages : [];
 }
 
+function hasReplayableTranscriptContent(events = []) {
+  return (Array.isArray(events) ? events : []).some((event) => (
+    event?.kind === 'user_message' ||
+    event?.kind === 'assistant_text_delta' ||
+    event?.kind === 'assistant_content_block' ||
+    event?.kind === 'reasoning_delta' ||
+    event?.kind === 'tool_call_start' ||
+    event?.kind === 'tool_result' ||
+    event?.kind === 'plan_update' ||
+    event?.kind === 'system_notice'
+  ));
+}
+
 async function normalizeLegacyLoadResult(result, provider, sessionId) {
   const messages = await flattenLegacyMessages(result);
   const legacyEvents = normalizeLegacyHistoryEntries(messages, provider, sessionId);
@@ -37,43 +51,46 @@ async function normalizeLegacyLoadResult(result, provider, sessionId) {
   };
 }
 
-function mergeSessionLists(legacySessions = [], acpSessions = []) {
-  const merged = new Map();
-
-  legacySessions.forEach((session) => {
-    if (session?.id) {
-      merged.set(session.id, session);
-    }
-  });
-
-  acpSessions.forEach((session) => {
-    if (session?.id) {
-      merged.set(session.id, session);
-    }
-  });
-
-  return Array.from(merged.values()).sort((left, right) => {
-    const leftTime = new Date(left?.lastActivity || left?.updatedAt || left?.createdAt || 0).getTime();
-    const rightTime = new Date(right?.lastActivity || right?.updatedAt || right?.createdAt || 0).getTime();
-    return rightTime - leftTime;
-  });
+function createEventLoadResult(events = [], source = 'acp') {
+  const normalizedEvents = Array.isArray(events) ? events : [];
+  return {
+    events: normalizedEvents,
+    total: normalizedEvents.length,
+    hasMore: false,
+    offset: 0,
+    limit: null,
+    source
+  };
 }
 
-async function loadAcpEvents(provider, sessionId) {
+async function loadAcpEvents(provider, sessionId, nativeHistoryLoader = null) {
   const record = await findAcpSessionRecord(sessionId, provider);
   if (!record) {
     return null;
   }
 
-  const events = await readMirroredConversationEvents(provider, sessionId);
-  return {
-    events,
-    total: events.length,
-    hasMore: false,
-    offset: 0,
-    limit: null,
-    source: 'acp'
-  };
+  const mirroredEvents = await readMirroredConversationEvents(provider, sessionId);
+  if (hasReplayableTranscriptContent(mirroredEvents)) {
+    return createEventLoadResult(mirroredEvents, 'acp');
+  }
+
+  if (typeof nativeHistoryLoader === 'function') {
+    try {
+      const nativeResult = await nativeHistoryLoader();
+      const normalizedResult = await normalizeLegacyLoadResult(nativeResult, provider, sessionId);
+      if (Array.isArray(normalizedResult)) {
+        return createEventLoadResult(normalizedResult, 'acp');
+      }
+      return {
+        ...normalizedResult,
+        source: 'acp'
+      };
+    } catch {
+      // Fall back to the mirrored event store when native history is unavailable.
+    }
+  }
+
+  return createEventLoadResult(mirroredEvents, 'acp');
 }
 
 const PROVIDER_ADAPTERS = {
@@ -85,11 +102,16 @@ const PROVIDER_ADAPTERS = {
       ]);
       return mergeSessionLists(
         (result?.sessions || []).map((session) => ({ ...session, provider: 'claude', source: 'legacy' })),
-        acpSessions
+        acpSessions,
+        { fallbackProvider: 'claude' }
       );
     },
     async loadEvents({ projectName, sessionId, limit = null, offset = 0 }) {
-      const acpResult = await loadAcpEvents('claude', sessionId);
+      const acpResult = await loadAcpEvents(
+        'claude',
+        sessionId,
+        () => getSessionMessages(projectName, sessionId, limit, offset),
+      );
       if (acpResult) {
         return acpResult;
       }
@@ -106,11 +128,16 @@ const PROVIDER_ADAPTERS = {
       ]);
       return mergeSessionLists(
         sessions.map((session) => ({ ...session, provider: 'codex', source: 'legacy' })),
-        acpSessions
+        acpSessions,
+        { fallbackProvider: 'codex' }
       );
     },
     async loadEvents({ sessionId, limit = null, offset = 0 }) {
-      const acpResult = await loadAcpEvents('codex', sessionId);
+      const acpResult = await loadAcpEvents(
+        'codex',
+        sessionId,
+        () => getCodexSessionMessages(sessionId, limit, offset),
+      );
       if (acpResult) {
         return acpResult;
       }
@@ -127,11 +154,16 @@ const PROVIDER_ADAPTERS = {
       ]);
       return mergeSessionLists(
         sessions.map((session) => ({ ...session, provider: 'gemini', source: 'legacy' })),
-        acpSessions
+        acpSessions,
+        { fallbackProvider: 'gemini' }
       );
     },
     async loadEvents({ sessionId, limit = null, offset = 0 }) {
-      const acpResult = await loadAcpEvents('gemini', sessionId);
+      const acpResult = await loadAcpEvents(
+        'gemini',
+        sessionId,
+        () => getGeminiSessionMessages(sessionId, limit, offset),
+      );
       if (acpResult) {
         return acpResult;
       }
@@ -148,11 +180,16 @@ const PROVIDER_ADAPTERS = {
       ]);
       return mergeSessionLists(
         sessions.map((session) => ({ ...session, provider: 'opencode', source: 'legacy' })),
-        acpSessions
+        acpSessions,
+        { fallbackProvider: 'opencode' }
       );
     },
     async loadEvents({ sessionId, limit = null, offset = 0 }) {
-      const acpResult = await loadAcpEvents('opencode', sessionId);
+      const acpResult = await loadAcpEvents(
+        'opencode',
+        sessionId,
+        () => getOpencodeSessionMessages(sessionId, limit, offset),
+      );
       if (acpResult) {
         return acpResult;
       }

package/server/session-core/runtimeState.js

@@ -266,6 +266,14 @@ function createRuntimeSignature(snapshot) {
   });
 }
 
+export function seedSessionRuntimeSubscriptionSnapshot(subscriptionKey, snapshot) {
+  if (!subscriptionKey || !snapshot) {
+    return;
+  }
+
+  lastBroadcastSignatures.set(subscriptionKey, createRuntimeSignature(snapshot));
+}
+
 export function createSessionRuntimeSubscriptionKey(provider, sessionId) {
   const normalizedProvider = normalizeProvider(provider);
   const normalizedSessionId = normalizeNonEmptyString(sessionId);

package/server/session-core/sessionListMerge.js

@@ -0,0 +1,47 @@
+function getSessionActivityTime(session) {
+  return new Date(
+    session?.lastActivity
+    || session?.updatedAt
+    || session?.updated_at
+    || session?.createdAt
+    || session?.created_at
+    || 0
+  ).getTime();
+}
+
+function buildSessionMergeKey(session, fallbackProvider = '') {
+  const provider = String(session?.provider || session?.__provider || fallbackProvider || '').trim().toLowerCase();
+  const sessionId = String(session?.id || session?.sessionId || '').trim();
+
+  if (!sessionId) {
+    return null;
+  }
+
+  return `${provider}:${sessionId}`;
+}
+
+export function mergeSessionLists(legacySessions = [], acpSessions = [], options = {}) {
+  const { fallbackProvider = '' } = options;
+  const merged = new Map();
+
+  for (const session of legacySessions) {
+    const mergeKey = buildSessionMergeKey(session, fallbackProvider);
+    if (!mergeKey) {
+      continue;
+    }
+
+    merged.set(mergeKey, { ...session });
+  }
+
+  for (const session of acpSessions) {
+    const mergeKey = buildSessionMergeKey(session, fallbackProvider);
+    if (!mergeKey) {
+      continue;
+    }
+
+    const existing = merged.get(mergeKey) || {};
+    merged.set(mergeKey, { ...existing, ...session });
+  }
+
+  return Array.from(merged.values()).sort((left, right) => getSessionActivityTime(right) - getSessionActivityTime(left));
+}

package/shared/conversationEvents.js

@@ -27,6 +27,9 @@ export const CONVERSATION_EVENT_KINDS = {
   PLAN_UPDATE: 'plan_update',
   MODE_UPDATE: 'mode_update',
   AVAILABLE_COMMANDS_UPDATE: 'available_commands_update',
+  CONFIG_OPTION_UPDATE: 'config_option_update',
+  SESSION_INFO_UPDATE: 'session_info_update',
+  USAGE_UPDATE: 'usage_update',
   APPROVAL_REQUEST: 'approval_request',
   APPROVAL_RESOLVED: 'approval_resolved',
   ARTIFACT_CREATED: 'artifact_created',
@@ -185,11 +188,61 @@ function createTextEndEvent({
   ];
 }
 
+function extractProtocolUserMessage(value) {
+  const text = String(value || '').trim();
+  if (!text) {
+    return null;
+  }
+
+  const dynamicContextMatch = text.match(
+    /<dynamic_context(?:\s[^>]*)?>[\s\S]*?<\/dynamic_context>\s*<user_message(?:\s[^>]*)?>\s*([\s\S]*?)\s*<\/user_message>/i
+  );
+  if (!dynamicContextMatch) {
+    return null;
+  }
+
+  return String(dynamicContextMatch[1] || '').trim();
+}
+
+function hasAcpProtocolTags(value) {
+  return /<\/?(?:subagent_notification|environment_context|dynamic_context|user_message)(?:\s[^>]*)?>/i.test(String(value || ''));
+}
+
+export function stripAssistantProtocolTags(text) {
+  if (typeof text !== 'string') {
+    return text;
+  }
+
+  const visibleUserMessage = extractProtocolUserMessage(text);
+  if (visibleUserMessage != null) {
+    return visibleUserMessage;
+  }
+
+  const hadProtocolTags = hasAcpProtocolTags(text);
+  let result = text;
+
+  result = result.replace(/<subagent_notification(?:\s[^>]*)?>[\s\S]*?<\/subagent_notification>/gi, '');
+  result = result.replace(/<environment_context(?:\s[^>]*)?>[\s\S]*?<\/environment_context>/gi, '');
+  result = result.replace(/<dynamic_context(?:\s[^>]*)?>[\s\S]*?<\/dynamic_context>/gi, '');
+  result = result.replace(/<\/?(?:subagent_notification|environment_context|dynamic_context|user_message)(?:\s[^>]*)?>/gi, '');
+
+  if (hadProtocolTags) {
+    result = result.replace(/["']?\s*\}\s*\}\s*$/g, '');
+  }
+
+  return result.trim();
+}
+
 function extractVisibleUserMessage(value) {
   const text = String(value || '').trim();
   if (!text) return '';
 
-  if (text.startsWith('# AGENTS.md instructions for ') || text.includes('<environment_context>')) {
+  if (
+    text.startsWith('# AGENTS.md instructions for ') ||
+    text.includes('<environment_context>') ||
+    text.startsWith('<subagent_notification>') ||
+    text.startsWith('</subagent_notification>')
+  ) {
     return '';
   }
 
@@ -202,11 +255,9 @@ function extractVisibleUserMessage(value) {
     return '';
   }
 
-  const dynamicContextMatch = text.match(
-    /^<dynamic_context(?:\s[^>]*)?>[\s\S]*?<\/dynamic_context>\s*<user_message>\s*([\s\S]*?)\s*<\/user_message>$/i
-  );
-  if (dynamicContextMatch) {
-    return String(dynamicContextMatch[1] || '').trim();
+  const protocolUserMessage = extractProtocolUserMessage(text);
+  if (protocolUserMessage != null) {
+    return protocolUserMessage;
   }
 
   return text;
@@ -222,12 +273,16 @@ function isHiddenSystemContextContent(value) {
     text.startsWith('[Dynamic Context]') ||
     text.startsWith('[Hidden Context]') ||
     text.startsWith('# AGENTS.md instructions for ') ||
-    text.startsWith('[DYNAMIC CONTEXT V1]')
+    text.startsWith('[DYNAMIC CONTEXT V1]') ||
+    text.startsWith('<subagent_notification>') ||
+    text.startsWith('</subagent_notification>')
   ) {
     return true;
   }
 
-  return /^<dynamic_context(?:\s|>)/i.test(text) || text.includes('<environment_context>');
+  return /^<dynamic_context(?:\s|>)/i.test(text)
+    || text.includes('<environment_context>')
+    || /<subagent_notification(?:\s|>)/i.test(text);
 }
 
 function stringifyToolContent(value) {
@@ -365,6 +420,71 @@ function normalizeAcpAvailableCommands(value) {
     }));
 }
 
+function normalizeAcpConfigOptions(value) {
+  const configOptions = Array.isArray(value?.configOptions)
+    ? value.configOptions
+    : Array.isArray(value)
+      ? value
+      : [];
+
+  return configOptions
+    .filter((option) => option && typeof option === 'object' && String(option.key || '').trim())
+    .map((option) => ({
+      key: String(option.key).trim(),
+      description: typeof option.description === 'string' ? option.description : '',
+      value: cloneJsonValue(option.value),
+      schema: option.schema && typeof option.schema === 'object' ? cloneJsonValue(option.schema) : null
+    }));
+}
+
+function normalizeAcpSessionInfo(value) {
+  if (!value || typeof value !== 'object') {
+    return null;
+  }
+
+  const title = Object.prototype.hasOwnProperty.call(value, 'title')
+    ? (value.title == null ? null : String(value.title))
+    : undefined;
+  const updatedAt = Object.prototype.hasOwnProperty.call(value, 'updatedAt')
+    ? (value.updatedAt == null ? null : String(value.updatedAt))
+    : undefined;
+
+  if (title === undefined && updatedAt === undefined) {
+    return null;
+  }
+
+  return {
+    ...(title !== undefined ? { title } : {}),
+    ...(updatedAt !== undefined ? { updatedAt } : {})
+  };
+}
+
+function normalizeAcpTokenUsage(value) {
+  if (!value || typeof value !== 'object') {
+    return null;
+  }
+
+  const used = Number(value.used);
+  const total = Number(value.size);
+  if (!Number.isFinite(used) || used < 0 || !Number.isFinite(total) || total < 0) {
+    return null;
+  }
+
+  const safeUsed = Math.round(used);
+  const safeTotal = Math.round(total);
+  const percentage = safeTotal > 0
+    ? Math.min(100, Math.max(0, Math.round((safeUsed / safeTotal) * 100)))
+    : 0;
+
+  return {
+    used: safeUsed,
+    total: safeTotal,
+    percentage,
+    remaining: Math.max(0, safeTotal - safeUsed),
+    cost: value.cost && typeof value.cost === 'object' ? cloneJsonValue(value.cost) : null
+  };
+}
+
 function mergeToolCallSnapshot(existingSnapshot = null, payload = {}) {
   const nextSnapshot = existingSnapshot && typeof existingSnapshot === 'object'
     ? { ...existingSnapshot }
@@ -613,8 +733,11 @@ export function normalizeLegacyHistoryEntries(rawMessages = [], provider = 'clau
     if (msg?.message?.role === 'assistant' && msg?.message?.content) {
       if (Array.isArray(msg.message.content)) {
         for (const part of msg.message.content) {
-          if (part?.type === 'text' && !isHiddenSystemContextContent(part.text)) {
-            events.push(...createTextSpanEvents({ text: part.text, provider, sessionId, timestamp, rawRef }));
+          if (part?.type === 'text') {
+            const cleanText = stripAssistantProtocolTags(part.text);
+            if (cleanText && !isHiddenSystemContextContent(cleanText)) {
+              events.push(...createTextSpanEvents({ text: cleanText, provider, sessionId, timestamp, rawRef }));
+            }
           } else if (part?.type === 'tool_use') {
             const toolCallId = part.id || createEventId('tool');
             const result = toolResults.get(part.id);
@@ -633,8 +756,11 @@ export function normalizeLegacyHistoryEntries(rawMessages = [], provider = 'clau
             }
           }
         }
-      } else if (!isHiddenSystemContextContent(msg.message.content)) {
-        events.push(...createTextSpanEvents({ text: msg.message.content, provider, sessionId, timestamp, rawRef }));
+      } else {
+        const cleanText = stripAssistantProtocolTags(msg.message.content);
+        if (cleanText && !isHiddenSystemContextContent(cleanText)) {
+          events.push(...createTextSpanEvents({ text: cleanText, provider, sessionId, timestamp, rawRef }));
+        }
       }
       continue;
     }
@@ -660,6 +786,12 @@ export function applyConversationEventToTimelineMessages(messages = [], event, s
       const clientRequestId = getConversationEventClientRequestId(event);
       const optimisticIndex = findMatchingOptimisticUserMessageIndex(nextMessages, event, payload);
       const normalizedContentBlocks = normalizeMessageContentBlocks(payload.contentBlocks);
+      const rawText = typeof payload.text === 'string' ? payload.text : '';
+      const visibleText = rawText ? extractVisibleUserMessage(rawText) : '';
+
+      if (rawText.trim() && !visibleText && normalizedContentBlocks.length === 0) {
+        break;
+      }
 
       if (optimisticIndex >= 0) {
         const existingMessage = nextMessages[optimisticIndex] || {};
@@ -670,7 +802,7 @@ export function applyConversationEventToTimelineMessages(messages = [], event, s
         nextMessages[optimisticIndex] = {
           ...existingMessage,
           type: 'user',
-          content: payload.text || existingMessage.content || '',
+          content: visibleText || existingMessage.content || '',
           timestamp: existingMessage.timestamp || timestamp,
           provider,
           contentBlocks: nextContentBlocks,
@@ -683,7 +815,7 @@ export function applyConversationEventToTimelineMessages(messages = [], event, s
 
       nextMessages.push({
         type: 'user',
-        content: payload.text || '',
+        content: visibleText,
         timestamp,
         provider,
         contentBlocks: normalizedContentBlocks,
@@ -929,6 +1061,9 @@ export function applyConversationEventToTimelineMessages(messages = [], event, s
     case CONVERSATION_EVENT_KINDS.SESSION_STATE_CHANGED:
     case CONVERSATION_EVENT_KINDS.MODE_UPDATE:
     case CONVERSATION_EVENT_KINDS.AVAILABLE_COMMANDS_UPDATE:
+    case CONVERSATION_EVENT_KINDS.CONFIG_OPTION_UPDATE:
+    case CONVERSATION_EVENT_KINDS.SESSION_INFO_UPDATE:
+    case CONVERSATION_EVENT_KINDS.USAGE_UPDATE:
     case CONVERSATION_EVENT_KINDS.ARTIFACT_CREATED:
     default:
       break;
@@ -952,7 +1087,10 @@ export function conversationEventsToTimelineMessages(events = [], sessionProvide
 export function extractAcpSessionMetadataFromConversationEvents(events = []) {
   const metadata = {
     modeState: null,
-    availableCommands: []
+    availableCommands: [],
+    configOptions: [],
+    sessionInfo: null,
+    tokenUsage: null
   };
 
   for (const event of Array.isArray(events) ? events : []) {
@@ -977,6 +1115,27 @@ export function extractAcpSessionMetadataFromConversationEvents(events = []) {
     if (event.kind === CONVERSATION_EVENT_KINDS.AVAILABLE_COMMANDS_UPDATE) {
       metadata.availableCommands = normalizeAcpAvailableCommands(event.payload || {});
     }
+
+    if (event.kind === CONVERSATION_EVENT_KINDS.CONFIG_OPTION_UPDATE) {
+      metadata.configOptions = normalizeAcpConfigOptions(event.payload || {});
+    }
+
+    if (event.kind === CONVERSATION_EVENT_KINDS.SESSION_INFO_UPDATE) {
+      const nextSessionInfo = normalizeAcpSessionInfo(event.payload || {});
+      if (nextSessionInfo) {
+        metadata.sessionInfo = {
+          ...(metadata.sessionInfo && typeof metadata.sessionInfo === 'object' ? metadata.sessionInfo : {}),
+          ...nextSessionInfo
+        };
+      }
+    }
+
+    if (event.kind === CONVERSATION_EVENT_KINDS.USAGE_UPDATE) {
+      const nextTokenUsage = normalizeAcpTokenUsage(event.payload || {});
+      if (nextTokenUsage) {
+        metadata.tokenUsage = nextTokenUsage;
+      }
+    }
   }
 
   return metadata;