@ixo/common 1.1.34 → 1.1.36

package/src/services/memory-engine/memory-engine.service.ts

@@ -10,6 +10,8 @@ interface MemoryEngineAuthHeaders {
   userToken: string;
   oracleHomeServer: string;
   userHomeServer: string;
+  /** When set, uses UCAN auth instead of Matrix tokens */
+  ucanInvocation?: string;
 }
 
 export class MemoryEngineService {
@@ -17,6 +19,31 @@ export class MemoryEngineService {
 
   constructor(private readonly memoryEngineUrl: string) {}
 
+  /**
+   * Build HTTP headers for memory engine requests (UCAN or Matrix)
+   */
+  private buildHeaders(
+    auth: MemoryEngineAuthHeaders,
+    roomId: string,
+  ): Record<string, string> {
+    if (auth.ucanInvocation) {
+      return {
+        Authorization: `Bearer ${auth.ucanInvocation}`,
+        'X-Auth-Type': 'ucan',
+        'x-room-id': roomId,
+        'Content-Type': 'application/json',
+      };
+    }
+    return {
+      'x-oracle-token': auth.oracleToken,
+      'x-user-token': auth.userToken,
+      'x-oracle-matrix-homeserver': auth.oracleHomeServer,
+      'x-user-matrix-homeserver': auth.userHomeServer,
+      'x-room-id': roomId,
+      'Content-Type': 'application/json',
+    };
+  }
+
   /**
    * Wraps a promise with a timeout, returning fallback value if timeout is exceeded
    */
@@ -43,6 +70,8 @@ export class MemoryEngineService {
     userToken: string;
     oracleHomeServer: string;
     userHomeServer: string;
+    /** When set, uses UCAN auth instead of Matrix tokens */
+    ucanInvocation?: string;
   }): Promise<UserContextData> {
     const {
       oracleDid,
@@ -51,6 +80,7 @@ export class MemoryEngineService {
       userToken,
       oracleHomeServer,
       userHomeServer,
+      ucanInvocation,
     } = params;
 
     Logger.info(
@@ -59,11 +89,12 @@ export class MemoryEngineService {
 
     try {
       // Execute all 6 queries in parallel with timeouts using Promise.allSettled
-      const authHeaders = {
+      const authHeaders: MemoryEngineAuthHeaders = {
         oracleToken,
         userToken,
         oracleHomeServer,
         userHomeServer,
+        ucanInvocation,
       };
 
       const results = await Promise.allSettled([
@@ -373,6 +404,7 @@ export class MemoryEngineService {
     userToken,
     oracleHomeServer,
     userHomeServer,
+    ucanInvocation,
   }: {
     messages: Array<{
       content: string;
@@ -386,6 +418,8 @@ export class MemoryEngineService {
     userToken: string;
     oracleHomeServer: string;
     userHomeServer: string;
+    /** When set, uses UCAN auth instead of Matrix tokens */
+    ucanInvocation?: string;
   }): Promise<{ success: boolean }> {
     if (!roomId) {
       Logger.warn(
@@ -393,9 +427,9 @@ export class MemoryEngineService {
       );
       return { success: false };
     }
-    if (!oracleToken || !userToken) {
+    if (!ucanInvocation && (!oracleToken || !userToken)) {
       Logger.warn(
-        `[MemoryEngineService] Missing oracle or user token, skipping conversation processing`,
+        `[MemoryEngineService] Missing auth (no UCAN and no Matrix tokens), skipping conversation processing`,
       );
       return { success: false };
     }
@@ -407,16 +441,16 @@ export class MemoryEngineService {
     }
 
     try {
+      const auth: MemoryEngineAuthHeaders = {
+        oracleToken,
+        userToken,
+        oracleHomeServer,
+        userHomeServer,
+        ucanInvocation,
+      };
       const response = await fetch(`${this.memoryEngineUrl}/messages`, {
         method: 'POST',
-        headers: {
-          'x-oracle-token': oracleToken,
-          'x-user-token': userToken,
-          'x-oracle-matrix-homeserver': oracleHomeServer,
-          'x-user-matrix-homeserver': userHomeServer,
-          'x-room-id': roomId,
-          'Content-Type': 'application/json',
-        },
+        headers: this.buildHeaders(auth, roomId),
         body: JSON.stringify({ messages }),
       });
 
@@ -455,9 +489,9 @@ export class MemoryEngineService {
       );
       return undefined;
     }
-    if (!auth.oracleToken || !auth.userToken) {
+    if (!auth.ucanInvocation && (!auth.oracleToken || !auth.userToken)) {
       Logger.warn(
-        `[MemoryEngineService] Missing oracle or user token, skipping query "${request.query}"`,
+        `[MemoryEngineService] Missing auth (no UCAN and no Matrix tokens), skipping query "${request.query}"`,
       );
       return undefined;
     }
@@ -465,14 +499,7 @@ export class MemoryEngineService {
     try {
       const response = await fetch(`${this.memoryEngineUrl}/search-enhanced`, {
         method: 'POST',
-        headers: {
-          'x-oracle-token': auth.oracleToken,
-          'x-user-token': auth.userToken,
-          'x-oracle-matrix-homeserver': auth.oracleHomeServer,
-          'x-user-matrix-homeserver': auth.userHomeServer,
-          'x-room-id': roomId,
-          'Content-Type': 'application/json',
-        },
+        headers: this.buildHeaders(auth, roomId),
         body: JSON.stringify(request),
       });
 

package/src/services/session-manager/dto.ts

@@ -32,6 +32,11 @@ export class ListChatSessionsDto extends UserAuthDto {
   @IsOptional()
   @Min(0)
   offset?: number;
+
+  /** Filter sessions by roomId. When set, only sessions in this room are returned. */
+  @IsString()
+  @IsOptional()
+  roomId?: string;
 }
 
 export class CreateChatSessionDto extends UserAuthDto {
@@ -66,6 +71,15 @@ export class CreateChatSessionDto extends UserAuthDto {
   @IsString()
   @IsOptional()
   userHomeServer?: string;
+
+  @IsString()
+  @IsOptional()
+  ucanInvocation?: string;
+
+  /** Override the roomId stored on the session (e.g. task-specific room). */
+  @IsString()
+  @IsOptional()
+  roomId?: string;
 }
 
 export class DeleteChatSessionDto extends UserAuthDto {

package/src/services/session-manager/session-manager.service.ts

@@ -326,19 +326,32 @@ ___________________________________________________________
     const limit = listSessionsDto.limit ?? 20;
     const offset = listSessionsDto.offset ?? 0;
 
-    // Get paginated sessions with total count
-    const rows = db
-      .prepare(
-        `SELECT
+    // Get paginated sessions with total count, optionally filtered by roomId
+    const hasRoomFilter = !!listSessionsDto.roomId;
+    const sql = hasRoomFilter
+      ? `SELECT
           session_id, title, last_updated_at, created_at, oracle_name,
           oracle_did, oracle_entity_did, last_processed_count,
           user_context, room_id, slack_thread_ts,
           COUNT(*) OVER() as total
          FROM sessions
+         WHERE room_id = ?
          ORDER BY last_updated_at DESC
-         LIMIT ? OFFSET ?`,
-      )
-      .all(limit, offset) as Array<{
+         LIMIT ? OFFSET ?`
+      : `SELECT
+          session_id, title, last_updated_at, created_at, oracle_name,
+          oracle_did, oracle_entity_did, last_processed_count,
+          user_context, room_id, slack_thread_ts,
+          COUNT(*) OVER() as total
+         FROM sessions
+         ORDER BY last_updated_at DESC
+         LIMIT ? OFFSET ?`;
+
+    const params = hasRoomFilter
+      ? [listSessionsDto.roomId, limit, offset]
+      : [limit, offset];
+
+    const rows = db.prepare(sql).all(...params) as Array<{
       session_id: string;
       title: string | null;
       last_updated_at: string;
@@ -380,11 +393,18 @@ ___________________________________________________________
     const userHomeServer =
       createSessionDto.homeServer ||
       (await getMatrixHomeServerCroppedForDid(createSessionDto.did));
-    const { roomId } = await this.matrixManger.getOracleRoomIdWithHomeServer({
-      userDid: createSessionDto.did,
-      oracleEntityDid: createSessionDto.oracleEntityDid,
-      userHomeServer,
-    });
+
+    // Use the provided roomId override (e.g. task-specific room),
+    // or fall back to resolving the user's main oracle room.
+    let roomId = createSessionDto.roomId;
+    if (!roomId) {
+      const resolved = await this.matrixManger.getOracleRoomIdWithHomeServer({
+        userDid: createSessionDto.did,
+        oracleEntityDid: createSessionDto.oracleEntityDid,
+        userHomeServer,
+      });
+      roomId = resolved.roomId;
+    }
 
     if (!roomId) {
       throw new Error('Room ID not found');
@@ -401,18 +421,19 @@ ___________________________________________________________
     let userContext: UserContextData | undefined;
     if (
       this.memoryEngineService &&
-      createSessionDto.oracleToken &&
-      createSessionDto.userToken
+      (createSessionDto.ucanInvocation ||
+        (createSessionDto.oracleToken && createSessionDto.userToken))
     ) {
       try {
         Logger.debug('Gathering user context from Memory Engine');
         userContext = await this.memoryEngineService.gatherUserContext({
           oracleDid: createSessionDto.oracleDid,
           roomId,
-          oracleToken: createSessionDto.oracleToken,
-          userToken: createSessionDto.userToken,
+          oracleToken: createSessionDto.oracleToken ?? '',
+          userToken: createSessionDto.userToken ?? '',
           oracleHomeServer: createSessionDto.oracleHomeServer ?? '',
           userHomeServer: createSessionDto.userHomeServer ?? '',
+          ucanInvocation: createSessionDto.ucanInvocation,
         });
       } catch (error) {
         Logger.error('Failed to gather user context:', error);

package/src/utils/get-user-subscription.ts

@@ -34,25 +34,32 @@ export interface GetUserSubscriptionParams {
   network: 'mainnet' | 'testnet' | 'devnet';
   bearerToken: string;
   subscriptionUrl?: string;
+  /** When set to 'ucan', includes X-Auth-Type header for UCAN invocation auth */
+  authType?: 'ucan';
 }
 
 export const getUserSubscription = async ({
   bearerToken,
   network,
   subscriptionUrl: _subscriptionUrl,
+  authType,
 }: GetUserSubscriptionParams): Promise<GetMySubscriptionsResponseDto | null> => {
   const subscriptionUrl =
     _subscriptionUrl ?? getSubscriptionUrlByNetwork(network);
   try {
     Logger.debug('Fetching user subscription from:', subscriptionUrl);
+    const headers: Record<string, string> = {
+      Authorization: `Bearer ${bearerToken}`,
+      'Content-Type': 'application/json',
+    };
+    if (authType === 'ucan') {
+      headers['X-Auth-Type'] = 'ucan';
+    }
     const response = await fetch(
       `${subscriptionUrl.endsWith('/') ? subscriptionUrl.slice(0, -1) : subscriptionUrl}/api/v1/subscriptions`,
       {
         method: 'GET',
-        headers: {
-          Authorization: `Bearer ${bearerToken}`,
-          'Content-Type': 'application/json',
-        },
+        headers,
       },
     );