@ixo/common 1.1.0

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

@@ -0,0 +1,405 @@
+import { Logger } from '@ixo/logger';
+import { MatrixManager } from '@ixo/matrix';
+import { getMatrixHomeServerCroppedForDid } from '@ixo/oracles-chain-client';
+import { Database } from 'better-sqlite3';
+import { getChatOpenAiModel } from '../../ai/index.js';
+import { MemoryEngineService } from '../memory-engine/memory-engine.service.js';
+import { type UserContextData } from '../memory-engine/types.js';
+import {
+  type ChatSession,
+  type CreateChatSessionDto,
+  type CreateChatSessionResponseDto,
+  type DeleteChatSessionDto,
+  type ListChatSessionsDto,
+  type ListChatSessionsResponseDto,
+} from './dto.js';
+
+export interface IDatabaseSyncService {
+  getUserDatabase(userDid: string): Promise<Database>;
+}
+
+export class SessionManagerService {
+  constructor(
+    private readonly syncService: IDatabaseSyncService,
+    public readonly matrixManger = MatrixManager.getInstance(),
+    private readonly memoryEngineService?: MemoryEngineService,
+  ) {}
+
+  public getSessionsStateKey({
+    oracleEntityDid,
+  }: {
+    oracleEntityDid: string;
+  }): `${string}_${string}` {
+    return `${oracleEntityDid}_sessions`;
+  }
+
+  private async createMessageTitle({
+    messages,
+  }: {
+    messages: string[];
+  }): Promise<string> {
+    if (messages.length === 0) {
+      return 'Untitled';
+    }
+    const llm = getChatOpenAiModel({
+      model: 'meta-llama/llama-3.1-8b-instruct',
+      temperature: 0.3,
+      apiKey: process.env.OPEN_ROUTER_API_KEY,
+      timeout: 20 * 1000 * 60, // 20 minutes
+      configuration: {
+        baseURL: 'https://openrouter.ai/api/v1',
+      },
+    });
+    const response = await llm.invoke(
+      `Based on this messages messages, Add a title for this convo and only based on the messages? MAKE SURE TO ONLY RESPOND WITH THE TITLE. 
+      
+      ## RESPONSE FORMAT
+      ONLY RESPOND WITH THE TITLE not anything else that title will be saved to the store directly from your response so generated based on the messages.
+
+      EXample
+
+      Input:
+      <messages>
+      Hello, how are you?
+      I'm good, thank you!
+      did u see the new feature i added?
+      yes but i didn't like it
+      </messages>
+
+      Output:
+      Conversation about a new feature
+
+      ___________________________________________________________
+
+      Input:
+      <messages>
+      What are the store opening hours?
+      We are open from 9am to 5pm, Monday to Friday.
+      </messages>
+
+      Output:
+      Store Opening Hours Information
+___________________________________________________________
+      Input:
+      <messages>
+      Can you help me reset my password?
+      Sure, I can assist you with that.
+      </messages>
+
+      Output:
+      Password Reset Assistance
+
+      ___________________________________________________________
+      # the out put should be only the title not anything else that title will be saved to the store directly from your response so generated based on the messages.
+
+      USER MESSAGES:
+      <messages>
+      ${messages.join('\n\n')}
+      </messages>
+      `,
+    );
+
+    const title = response.content.toString();
+    return title;
+  }
+
+  public async updateLastProcessedCount({
+    sessionId,
+    did,
+    lastProcessedCount,
+  }: {
+    sessionId: string;
+    did: string;
+    lastProcessedCount: number;
+  }): Promise<void> {
+    const db = await this.syncService.getUserDatabase(did);
+    db.prepare(
+      'UPDATE sessions SET last_processed_count = ? WHERE session_id = ?',
+    ).run(lastProcessedCount, sessionId);
+    return;
+  }
+
+  public async syncSessionSet({
+    sessionId,
+    did,
+    messages,
+    oracleEntityDid,
+    oracleName,
+    roomId: _roomId,
+    lastProcessedCount,
+    oracleDid,
+    userContext,
+    slackThreadTs,
+  }: {
+    sessionId: string;
+    did: string;
+    messages: string[];
+    oracleEntityDid: string;
+    oracleName: string;
+    roomId?: string;
+    lastProcessedCount?: number;
+    oracleDid: string;
+    userContext?: UserContextData;
+    slackThreadTs?: string;
+  }): Promise<ChatSession> {
+    const db = await this.syncService.getUserDatabase(did);
+
+    const selectedSession = await this.getSession(sessionId, did, false);
+
+    if (!selectedSession) {
+      const session: ChatSession = {
+        sessionId,
+        oracleName,
+        title: await this.createMessageTitle({
+          messages,
+        }),
+        lastUpdatedAt: new Date().toISOString(),
+        createdAt: new Date().toISOString(),
+        oracleEntityDid,
+        oracleDid,
+        userContext,
+        slackThreadTs,
+      };
+
+      // Always use SQLite
+      db.prepare(
+        `
+        INSERT INTO sessions (
+          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
+        )
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `,
+      ).run(
+        session.sessionId,
+        session.title ?? null,
+        session.lastUpdatedAt,
+        session.createdAt,
+        session.oracleName,
+        session.oracleDid,
+        session.oracleEntityDid,
+        session.lastProcessedCount ?? null,
+        session.userContext ? JSON.stringify(session.userContext) : null,
+        session.roomId ?? null,
+        session.slackThreadTs ?? null,
+      );
+
+      return session;
+    }
+
+    // 1. We have at least 2 messages (enough to generate a meaningful title)
+    // 2. AND the current title is "Untitled" or undefined (hasn't been set yet)
+    const hasEnoughMessages = messages.length >= 2;
+    const needsTitleUpdate =
+      !selectedSession.title ||
+      selectedSession.title.toLowerCase() === 'untitled' ||
+      (selectedSession.title && selectedSession.title.trim() === '');
+
+    const allowTitleUpdate = hasEnoughMessages && needsTitleUpdate; // update the session
+    const title = allowTitleUpdate
+      ? await this.createMessageTitle({
+          messages,
+        })
+      : selectedSession.title;
+
+    const lastUpdatedAt = new Date().toISOString();
+    const updatedSession: ChatSession = {
+      ...selectedSession,
+      title,
+      lastUpdatedAt,
+      lastProcessedCount,
+      slackThreadTs,
+    };
+
+    db.prepare(
+      `
+      UPDATE sessions 
+      SET title = ?, last_updated_at = ?, last_processed_count = ?, slack_thread_ts = ?
+      WHERE session_id = ?
+    `,
+    ).run(
+      updatedSession.title ?? null,
+      lastUpdatedAt,
+      updatedSession.lastProcessedCount ?? null,
+      updatedSession.slackThreadTs ?? null,
+      sessionId,
+    );
+
+    return updatedSession;
+  }
+
+  public async getSession(
+    sessionId: string,
+    did: string,
+    throwOnNotFound: boolean = true,
+  ): Promise<ChatSession | undefined> {
+    const db = await this.syncService.getUserDatabase(did);
+    const row = db
+      .prepare(
+        `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
+         FROM sessions 
+         WHERE session_id = ?`,
+      )
+      .get(sessionId) as
+      | {
+          session_id: string;
+          title: string | null;
+          last_updated_at: string;
+          created_at: string;
+          oracle_name: string;
+          oracle_did: string;
+          oracle_entity_did: string;
+          last_processed_count: number | null;
+          user_context: string | null;
+          room_id: string | null;
+          slack_thread_ts: string | null;
+        }
+      | undefined;
+
+    const selectedSession = row
+      ? {
+          sessionId: row.session_id,
+          title: row.title ?? undefined,
+          lastUpdatedAt: row.last_updated_at,
+          createdAt: row.created_at,
+          oracleName: row.oracle_name,
+          oracleDid: row.oracle_did,
+          oracleEntityDid: row.oracle_entity_did,
+          lastProcessedCount: row.last_processed_count ?? undefined,
+          userContext: row.user_context
+            ? (JSON.parse(row.user_context) as UserContextData)
+            : undefined,
+          roomId: row.room_id ?? undefined,
+          slackThreadTs: row.slack_thread_ts ?? undefined,
+        }
+      : undefined;
+
+    if (!selectedSession) {
+      if (throwOnNotFound) {
+        throw new Error('Session not found');
+      }
+      return undefined;
+    }
+
+    return selectedSession;
+  }
+
+  public async listSessions(
+    listSessionsDto: ListChatSessionsDto,
+  ): Promise<ListChatSessionsResponseDto> {
+    const db = await this.syncService.getUserDatabase(listSessionsDto.did);
+
+    // Set default pagination values
+    const limit = listSessionsDto.limit ?? 20;
+    const offset = listSessionsDto.offset ?? 0;
+
+    // Get paginated sessions with total count
+    const rows = db
+      .prepare(
+        `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 ?`,
+      )
+      .all(limit, offset) as Array<{
+      session_id: string;
+      title: string | null;
+      last_updated_at: string;
+      created_at: string;
+      oracle_name: string;
+      oracle_did: string;
+      oracle_entity_did: string;
+      last_processed_count: number | null;
+      user_context: string | null;
+      room_id: string | null;
+      slack_thread_ts: string | null;
+      total: number;
+    }>;
+    const total = rows[0]?.total ?? 0;
+
+    const sessions: ChatSession[] = rows.map((row) => ({
+      sessionId: row.session_id,
+      title: row.title ?? undefined,
+      lastUpdatedAt: row.last_updated_at,
+      createdAt: row.created_at,
+      oracleName: row.oracle_name,
+      oracleDid: row.oracle_did,
+      oracleEntityDid: row.oracle_entity_did,
+      lastProcessedCount: row.last_processed_count ?? undefined,
+      userContext: row.user_context
+        ? (JSON.parse(row.user_context) as UserContextData)
+        : undefined,
+      roomId: row.room_id ?? undefined,
+      slackThreadTs: row.slack_thread_ts ?? undefined,
+    }));
+
+    return { sessions, total };
+  }
+
+  public async createSession(
+    createSessionDto: CreateChatSessionDto,
+  ): Promise<CreateChatSessionResponseDto> {
+    const userHomeServer = createSessionDto.homeServer || await getMatrixHomeServerCroppedForDid(createSessionDto.did);
+    const { roomId } = await this.matrixManger.getOracleRoomIdWithHomeServer({
+      userDid: createSessionDto.did,
+      oracleEntityDid: createSessionDto.oracleEntityDid,
+      userHomeServer,
+    });
+
+    if (!roomId) {
+      throw new Error('Room ID not found');
+    }
+    const eventId = await this.matrixManger.sendMessage({
+      message: 'New Conversation Started',
+      roomId,
+      isOracleAdmin: true,
+    });
+
+    // Gather user context from Memory Engine
+    let userContext: UserContextData | undefined;
+    if (this.memoryEngineService) {
+      try {
+        Logger.debug('Gathering user context from Memory Engine');
+        userContext = await this.memoryEngineService.gatherUserContext({
+          oracleDid: createSessionDto.oracleDid,
+          userDid: createSessionDto.did,
+          roomId,
+        });
+      } catch (error) {
+        Logger.error('Failed to gather user context:', error);
+        throw error;
+      }
+    }
+
+    const session = await this.syncSessionSet({
+      sessionId: eventId,
+      oracleName: createSessionDto.oracleName,
+      did: createSessionDto.did,
+      oracleEntityDid: createSessionDto.oracleEntityDid,
+      oracleDid: createSessionDto.oracleDid,
+      messages: [],
+      roomId,
+      userContext,
+      slackThreadTs: createSessionDto.slackThreadTs,
+    });
+
+    return session;
+  }
+
+  public async deleteSession(
+    deleteSessionDto: DeleteChatSessionDto,
+  ): Promise<void> {
+    const db = await this.syncService.getUserDatabase(deleteSessionDto.did);
+    db.prepare('DELETE FROM sessions WHERE session_id = ?').run(
+      deleteSessionDto.sessionId,
+    );
+  }
+}

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

@@ -0,0 +1,84 @@
+import { Logger } from '@ixo/logger';
+
+export const getSubscriptionUrlByNetwork = (
+  network: 'mainnet' | 'testnet' | 'devnet',
+) => {
+  return {
+    mainnet: 'https://subscriptions-api-mainnet.ixo-api.workers.dev',
+    testnet: 'https://subscriptions-api-testnet.ixo-api.workers.dev',
+    devnet: 'https://subscriptions-api.ixo-api.workers.dev',
+  }[network];
+};
+
+export interface ClaimCollectionsDto {
+  oracleClaimsCollectionId?: string;
+
+  subscriptionClaimsCollectionId?: string;
+}
+
+export interface GetMySubscriptionsResponseDto {
+  claimCollections: ClaimCollectionsDto;
+  currentPlan: string;
+  currentPlanName: string;
+  totalCredits: number;
+  planCredits: number;
+  status: 'active' | 'inactive' | 'processing' | 'trial';
+  adminAddress: string;
+}
+
+interface GetUserSubscriptionResponse extends GetMySubscriptionsResponseDto {
+  manageSubscriptionUrl: string;
+}
+
+export interface GetUserSubscriptionParams {
+  network: 'mainnet' | 'testnet' | 'devnet';
+  bearerToken: string;
+  subscriptionUrl?: string;
+}
+
+export const getUserSubscription = async ({
+  bearerToken,
+  network,
+  subscriptionUrl: _subscriptionUrl,
+}: GetUserSubscriptionParams): Promise<GetMySubscriptionsResponseDto | null> => {
+  const subscriptionUrl =
+    _subscriptionUrl ?? getSubscriptionUrlByNetwork(network);
+  try {
+    Logger.debug('Fetching user subscription from:', subscriptionUrl);
+    const response = await fetch(
+      `${subscriptionUrl.endsWith('/') ? subscriptionUrl.slice(0, -1) : subscriptionUrl}/api/v1/subscriptions`,
+      {
+        method: 'GET',
+        headers: {
+          Authorization: `Bearer ${bearerToken}`,
+          'Content-Type': 'application/json',
+        },
+      },
+    );
+
+    if (!response.ok) {
+      console.error(
+        `Failed to fetch user subscription: ${response.status} ${response.statusText}`,
+      );
+      return null;
+    }
+
+    const data = await response.json();
+    if (!data) {
+      return null;
+    }
+    const subscription = data as GetUserSubscriptionResponse;
+    return {
+      claimCollections: subscription.claimCollections,
+      currentPlan: subscription.currentPlan,
+      currentPlanName: subscription.currentPlanName,
+      totalCredits: subscription.totalCredits,
+      planCredits: subscription.planCredits,
+      status: subscription.status,
+      adminAddress: subscription.adminAddress,
+    };
+  } catch (error) {
+    console.error('Error fetching user subscription:', error);
+    return null;
+  }
+};

package/src/utils/index.ts

@@ -0,0 +1 @@
+export * from './get-user-subscription.js';

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "extends": "@ixo/typescript-config/nestjs.json",
+  "compilerOptions": {
+    "baseUrl": "./",
+    "outDir": "dist",
+    "rootDir": "src",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "esModuleInterop": true,
+    "paths": {
+      "src/*": ["src/*"]
+    }
+  },
+  "include": ["src/**/*", "src/**/*.test.ts"],
+  "exclude": ["node_modules", "dist", "integration", "**/*.spec.ts"]
+}