@ixo/oracle-runtime 0.0.1

package/dist/modules/sessions/session-history-processor.service.js

@@ -0,0 +1,254 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var SessionHistoryProcessor_1;
+// VALUE imports required for Nest DI — `design:paramtypes` metadata needs
+// the runtime constructor, not a stripped `type`-only reference.
+import { MemoryEngineService, SessionManagerService } from '@ixo/common';
+import { MatrixManager } from '@ixo/matrix';
+import { getMatrixHomeServerCroppedForDid } from '@ixo/oracles-chain-client';
+import { CACHE_MANAGER } from '@nestjs/cache-manager';
+import { Inject, Injectable, Logger, Optional } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import { UserPreferencesService } from '../../plugins/user-preferences/service/user-preferences.service.js';
+import { MessagesService } from '../messages/messages.service.js';
+import { UcanService } from '../ucan/ucan.service.js';
+let SessionHistoryProcessor = SessionHistoryProcessor_1 = class SessionHistoryProcessor {
+    messagesService;
+    memoryEngineService;
+    sessionManagerService;
+    configService;
+    cacheManager;
+    ucanService;
+    logger = new Logger(SessionHistoryProcessor_1.name);
+    constructor(messagesService, memoryEngineService, sessionManagerService, configService, cacheManager, ucanService) {
+        this.messagesService = messagesService;
+        this.memoryEngineService = memoryEngineService;
+        this.sessionManagerService = sessionManagerService;
+        this.configService = configService;
+        this.cacheManager = cacheManager;
+        this.ucanService = ucanService;
+    }
+    /**
+     * Process session history by sending messages to memory engine.
+     * Uses cache locking to prevent concurrent processing for the same session.
+     */
+    async processSessionHistory(params) {
+        const cacheKey = `processing:session:${params.sessionId}`;
+        const lockTtl = 5 * 60 * 1000;
+        const maxRetries = 3;
+        const retryDelay = 10 * 1000;
+        const existingLock = await this.cacheManager.get(cacheKey);
+        if (existingLock) {
+            this.logger.debug(`Session ${params.sessionId} is already being processed, skipping`);
+            return;
+        }
+        await this.cacheManager.set(cacheKey, true, lockTtl);
+        try {
+            await this.processSessionHistoryWithRetry(params, maxRetries, retryDelay);
+        }
+        finally {
+            await this.cacheManager.del(cacheKey);
+        }
+    }
+    async processSessionHistoryWithRetry(params, maxRetries, retryDelay) {
+        const { sessionId } = params;
+        for (let attempt = 1; attempt <= maxRetries; attempt++) {
+            try {
+                await this.processSessionHistoryInternal(params);
+                this.logger.log(`Successfully processed session history for session ${sessionId}`);
+                return;
+            }
+            catch (error) {
+                this.logger.warn(`Attempt ${attempt}/${maxRetries} failed for session ${sessionId}:`, error);
+                if (attempt === maxRetries) {
+                    this.logger.error(`Failed to process session history for session ${sessionId} after ${maxRetries} attempts`, error);
+                    throw error;
+                }
+                await new Promise((resolve) => setTimeout(resolve, retryDelay));
+            }
+        }
+    }
+    async processSessionHistoryInternal({ sessionId, did, oracleEntityDid, homeServer, }) {
+        this.logger.debug(`Processing session history for session ${sessionId}`);
+        const session = await this.sessionManagerService.getSession(sessionId, did, false);
+        if (!session) {
+            this.logger.warn(`Session ${sessionId} not found, skipping processing`);
+            return;
+        }
+        const userHomeServer = homeServer || (await getMatrixHomeServerCroppedForDid(did));
+        const { roomId } = await this.sessionManagerService.matrixManger.getOracleRoomIdWithHomeServer({
+            userDid: did,
+            oracleEntityDid,
+            userHomeServer,
+        });
+        if (!roomId) {
+            this.logger.warn(`Room not found for session ${sessionId}, skipping processing`);
+            return;
+        }
+        const messagesResponse = await this.messagesService.listMessages({
+            sessionId,
+            did,
+            homeServer,
+        });
+        if (!messagesResponse.messages || messagesResponse.messages.length === 0) {
+            this.logger.debug(`No messages found for session ${sessionId}`);
+            return;
+        }
+        const lastProcessedCount = session.lastProcessedCount || 0;
+        const newMessages = messagesResponse.messages.slice(lastProcessedCount);
+        if (newMessages.length === 0) {
+            this.logger.debug(`No new messages to process for session ${sessionId} (lastProcessedCount: ${lastProcessedCount})`);
+            return;
+        }
+        // Speaker identities for graphiti's extractor. Without these, every
+        // message's episode body starts with the literal string "user" or
+        // "assistant" — graphiti's extraction prompt then creates entity nodes
+        // with those generic names and pins all extracted facts to them,
+        // polluting the graph. Real identities make the graph person-centric.
+        // Graphiti partitions memories per (user, oracle) via group_id, so a
+        // simple "Me"/"Oracle" fallback is collision-safe within a user's graph.
+        const prefs = await UserPreferencesService.getInstance()
+            .get(roomId)
+            .catch(() => undefined);
+        const userSpeakerLabel = await this.resolveUserDisplayName(did, prefs?.userName, userHomeServer);
+        const oracleSpeakerLabel = prefs?.agentName?.trim() ||
+            this.configService.get('ORACLE_NAME')?.trim() ||
+            'Oracle';
+        const transformedMessages = this.transformMessagesToMemoryEngineFormat(newMessages, session.title ?? '', userSpeakerLabel, oracleSpeakerLabel);
+        if (!this.ucanService?.hasSigningKey()) {
+            this.logger.warn(`No UCAN signing key for session ${sessionId}, skipping memory engine processing`);
+            return;
+        }
+        const oracleMatrixBaseUrl = this.configService
+            .getOrThrow('MATRIX_BASE_URL')
+            .replace(/\/$/, '');
+        const oracleHomeServer = oracleMatrixBaseUrl.replace(/^https?:\/\//, '');
+        let memoryUcanInvocation;
+        try {
+            const invocation = await this.ucanService.createServiceInvocation(this.configService.getOrThrow('MEMORY_ENGINE_URL'), did, 'ixo:memory');
+            if (invocation) {
+                memoryUcanInvocation = invocation;
+            }
+        }
+        catch (err) {
+            this.logger.warn(`[UCAN] Failed to create memory engine invocation: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        if (!memoryUcanInvocation) {
+            this.logger.warn(`Could not mint UCAN invocation for memory engine; skipping memory engine processing for session ${sessionId}`);
+            return;
+        }
+        const result = await this.memoryEngineService.processConversationHistory({
+            messages: transformedMessages,
+            roomId,
+            oracleHomeServer,
+            userHomeServer,
+            ucanInvocation: memoryUcanInvocation,
+        });
+        if (!result.success) {
+            throw new Error('Failed to send messages to memory engine');
+        }
+        const newLastProcessedCount = lastProcessedCount + newMessages.length;
+        await this.sessionManagerService.updateLastProcessedCount({
+            sessionId,
+            did,
+            lastProcessedCount: newLastProcessedCount,
+        });
+        this.logger.log(`Processed ${newMessages.length} new messages for session ${sessionId}, updated lastProcessedCount to ${newLastProcessedCount}`);
+    }
+    /**
+     * Transform LangChain messages into the role/content shape the
+     * memory engine expects. `userSpeakerLabel` and `oracleSpeakerLabel` become
+     * the `name` (and `role`) the memory engine sees for each message — these
+     * are what graphiti's extractor will use as the speaker entity in the graph,
+     * so they MUST be meaningful identities (not the literal strings
+     * "user"/"assistant"), otherwise every fact gets pinned to a generic
+     * placeholder node.
+     */
+    transformMessagesToMemoryEngineFormat(messages, sessionTitle, userSpeakerLabel, oracleSpeakerLabel) {
+        return messages.map((message) => {
+            let role_type;
+            let role;
+            let name;
+            switch (message.type) {
+                case 'human':
+                    role_type = 'user';
+                    role = userSpeakerLabel;
+                    name = userSpeakerLabel;
+                    break;
+                case 'ai':
+                    role_type = 'assistant';
+                    role = oracleSpeakerLabel;
+                    name = oracleSpeakerLabel;
+                    break;
+                case 'system':
+                    role_type = 'system';
+                    role = 'System';
+                    name = 'System';
+                    break;
+                case 'tool':
+                    // Memory engine has no tool role — fold tool replies into assistant.
+                    // Tool responses are framed as the oracle reporting back, so they
+                    // share the oracle speaker label.
+                    role_type = 'assistant';
+                    role = oracleSpeakerLabel;
+                    name = oracleSpeakerLabel;
+                    break;
+                default:
+                    role_type = 'user';
+                    role = userSpeakerLabel;
+                    name = userSpeakerLabel;
+            }
+            return {
+                content: message.content,
+                role_type,
+                role,
+                name,
+                source_description: `Chat Session: ${sessionTitle}`,
+            };
+        });
+    }
+    /**
+     * Resolve the user's display name for graphiti's speaker label. Cascade:
+     *   1. `userName` from preferences (caller passes it in — fetched once
+     *      alongside agentName)
+     *   2. Matrix profile displayname (looked up via @did-…:homeServer)
+     *   3. "Me" — safe fallback because each user has their own group_id
+     *      partition in graphiti, so a generic label can't collide cross-user.
+     */
+    async resolveUserDisplayName(did, prefsUserName, userHomeServer) {
+        const fromPrefs = prefsUserName?.trim();
+        if (fromPrefs)
+            return fromPrefs;
+        try {
+            const matrixUserId = `@did-${did.replace(/:/g, '-')}:${userHomeServer}`;
+            const displayName = await MatrixManager.getInstance().getDisplayName(matrixUserId);
+            const trimmed = displayName?.trim();
+            if (trimmed)
+                return trimmed;
+        }
+        catch (error) {
+            this.logger.warn(`[resolveUserDisplayName] matrix lookup failed for ${did}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        return 'Me';
+    }
+};
+SessionHistoryProcessor = SessionHistoryProcessor_1 = __decorate([
+    Injectable(),
+    __param(4, Inject(CACHE_MANAGER)),
+    __param(5, Optional()),
+    __metadata("design:paramtypes", [MessagesService,
+        MemoryEngineService,
+        SessionManagerService,
+        ConfigService, Object, UcanService])
+], SessionHistoryProcessor);
+export { SessionHistoryProcessor };

package/dist/modules/sessions/sessions.controller.d.ts

@@ -0,0 +1,13 @@
+import { type CreateChatSessionResponseDto, type ListChatSessionsResponseDto } from '@ixo/common';
+import type { Request } from 'express';
+import { SessionsService } from './sessions.service.js';
+export declare class SessionsController {
+    private readonly sessionsService;
+    constructor(sessionsService: SessionsService);
+    createSession(req: Request): Promise<CreateChatSessionResponseDto>;
+    listSessions(req: Request, limit?: number, offset?: number): Promise<ListChatSessionsResponseDto>;
+    deleteSession(req: Request, sessionId: string): Promise<{
+        message: string;
+    }>;
+}
+//# sourceMappingURL=sessions.controller.d.ts.map

package/dist/modules/sessions/sessions.controller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sessions.controller.d.ts","sourceRoot":"","sources":["../../../src/modules/sessions/sessions.controller.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,4BAA4B,EACjC,KAAK,2BAA2B,EACjC,MAAM,aAAa,CAAC;AAmBrB,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AACvC,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAExD,qBAEa,kBAAkB;IACjB,OAAO,CAAC,QAAQ,CAAC,eAAe;gBAAf,eAAe,EAAE,eAAe;IAWvD,aAAa,CACV,GAAG,EAAE,OAAO,GAClB,OAAO,CAAC,4BAA4B,CAAC;IA2BlC,YAAY,CACT,GAAG,EAAE,OAAO,EACH,KAAK,CAAC,EAAE,MAAM,EACb,MAAM,CAAC,EAAE,MAAM,GAC/B,OAAO,CAAC,2BAA2B,CAAC;IA2BjC,aAAa,CACV,GAAG,EAAE,OAAO,EACC,SAAS,EAAE,MAAM,GACpC,OAAO,CAAC;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;CAOhC"}

package/dist/modules/sessions/sessions.controller.js

@@ -0,0 +1,113 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { Controller, Delete, Get, HttpCode, HttpStatus, Param, Post, Query, Req, } from '@nestjs/common';
+import { ApiOperation, ApiParam, ApiQuery, ApiResponse, ApiTags, } from '@nestjs/swagger';
+import { SessionsService } from './sessions.service.js';
+let SessionsController = class SessionsController {
+    sessionsService;
+    constructor(sessionsService) {
+        this.sessionsService = sessionsService;
+    }
+    async createSession(req) {
+        const { did } = req.authData;
+        return this.sessionsService.createSession({
+            did,
+        });
+    }
+    async listSessions(req, limit, offset) {
+        const { did } = req.authData;
+        return this.sessionsService.listSessions({
+            did,
+            limit: limit ? Number(limit) : undefined,
+            offset: offset ? Number(offset) : undefined,
+        });
+    }
+    async deleteSession(req, sessionId) {
+        const { did } = req.authData;
+        return this.sessionsService.deleteSession({
+            did,
+            sessionId,
+        });
+    }
+};
+__decorate([
+    Post(),
+    HttpCode(HttpStatus.CREATED),
+    ApiOperation({ summary: 'Create a new session' }),
+    ApiResponse({ status: 201, description: 'Session created successfully.' }),
+    ApiResponse({
+        status: 400,
+        description: 'Bad Request (e.g., missing/invalid headers by middleware, or session creation failed).',
+    }),
+    __param(0, Req()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], SessionsController.prototype, "createSession", null);
+__decorate([
+    Get(),
+    ApiOperation({ summary: 'List all sessions for a user' }),
+    ApiQuery({
+        name: 'limit',
+        required: false,
+        type: Number,
+        description: 'Number of sessions to return (default: 20)',
+    }),
+    ApiQuery({
+        name: 'offset',
+        required: false,
+        type: Number,
+        description: 'Number of sessions to skip (default: 0)',
+    }),
+    ApiResponse({ status: 200, description: 'List of sessions retrieved.' }),
+    ApiResponse({
+        status: 400,
+        description: 'Bad Request (e.g., missing/invalid headers by middleware, or failed to list sessions).',
+    }),
+    __param(0, Req()),
+    __param(1, Query('limit')),
+    __param(2, Query('offset')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Number, Number]),
+    __metadata("design:returntype", Promise)
+], SessionsController.prototype, "listSessions", null);
+__decorate([
+    Delete(':sessionId'),
+    HttpCode(HttpStatus.OK),
+    ApiOperation({ summary: 'Delete a specific session' }),
+    ApiParam({
+        name: 'sessionId',
+        required: true,
+        description: 'ID of the session to delete',
+    }),
+    ApiResponse({ status: 200, description: 'Session deleted successfully.' }),
+    ApiResponse({
+        status: 400,
+        description: 'Bad Request (e.g., missing/invalid headers by middleware, or failed to delete session).',
+    }),
+    ApiResponse({
+        status: 404,
+        description: 'Session not found for the given ID.',
+    }),
+    __param(0, Req()),
+    __param(1, Param('sessionId')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, String]),
+    __metadata("design:returntype", Promise)
+], SessionsController.prototype, "deleteSession", null);
+SessionsController = __decorate([
+    ApiTags('sessions'),
+    Controller('sessions'),
+    __metadata("design:paramtypes", [SessionsService])
+], SessionsController);
+export { SessionsController };

package/dist/modules/sessions/sessions.module.d.ts

@@ -0,0 +1,3 @@
+export declare class SessionsModule {
+}
+//# sourceMappingURL=sessions.module.d.ts.map

package/dist/modules/sessions/sessions.module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sessions.module.d.ts","sourceRoot":"","sources":["../../../src/modules/sessions/sessions.module.ts"],"names":[],"mappings":"AAYA,qBA8Ba,cAAc;CAAG"}

package/dist/modules/sessions/sessions.module.js

@@ -0,0 +1,49 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { MemoryEngineService, SessionManagerService } from '@ixo/common';
+import { MatrixManager } from '@ixo/matrix';
+import { Module } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import { MessagesModule } from '../messages/messages.module.js';
+import { UcanModule } from '../ucan/ucan.module.js';
+import { CheckpointStorageSyncModule } from '../../matrix/checkpointer/user-matrix-sqlite-sync-service.module.js';
+import { UserMatrixSqliteSyncService } from '../../matrix/checkpointer/user-matrix-sqlite-sync-service.service.js';
+import { SessionHistoryProcessor } from './session-history-processor.service.js';
+import { SessionsController } from './sessions.controller.js';
+import { SessionsService } from './sessions.service.js';
+let SessionsModule = class SessionsModule {
+};
+SessionsModule = __decorate([
+    Module({
+        imports: [MessagesModule, CheckpointStorageSyncModule, UcanModule],
+        controllers: [SessionsController],
+        providers: [
+            SessionsService,
+            SessionHistoryProcessor,
+            {
+                // MEMORY_ENGINE_URL is optional — see comment in messages.module.ts.
+                provide: MemoryEngineService,
+                useFactory: (configService) => {
+                    const memoryEngineUrl = configService.get('MEMORY_ENGINE_URL');
+                    return memoryEngineUrl
+                        ? new MemoryEngineService(memoryEngineUrl)
+                        : null;
+                },
+                inject: [ConfigService],
+            },
+            {
+                provide: SessionManagerService,
+                useFactory: (syncService) => {
+                    return new SessionManagerService(syncService, MatrixManager.getInstance());
+                },
+                inject: [UserMatrixSqliteSyncService],
+            },
+        ],
+        exports: [SessionsService, SessionHistoryProcessor],
+    })
+], SessionsModule);
+export { SessionsModule };

package/dist/modules/sessions/sessions.service.d.ts

@@ -0,0 +1,23 @@
+import { type CreateChatSessionResponseDto, type ListChatSessionsResponseDto, SessionManagerService } from '@ixo/common';
+import { ConfigService } from '@nestjs/config';
+import { UcanService } from '../ucan/ucan.service.js';
+import { UserMatrixSqliteSyncService } from '../../matrix/checkpointer/user-matrix-sqlite-sync-service.service.js';
+import { type CreateSessionDto } from './dto/create-session.dto.js';
+import { type DeleteSessionDto } from './dto/delete-session.dto.js';
+import { type ListSessionsDto } from './dto/list-sessions.dto.js';
+import { SessionHistoryProcessor } from './session-history-processor.service.js';
+export declare class SessionsService {
+    private readonly sessionManager;
+    private readonly configService;
+    private readonly sessionHistoryProcessor;
+    private readonly syncService;
+    private readonly ucanService?;
+    constructor(sessionManager: SessionManagerService, configService: ConfigService, sessionHistoryProcessor: SessionHistoryProcessor, syncService: UserMatrixSqliteSyncService, ucanService?: UcanService | undefined);
+    processPreviousSessionHistory(data: CreateSessionDto): Promise<void>;
+    createSession(data: CreateSessionDto): Promise<CreateChatSessionResponseDto>;
+    listSessions(data: ListSessionsDto): Promise<ListChatSessionsResponseDto>;
+    deleteSession(data: DeleteSessionDto): Promise<{
+        message: string;
+    }>;
+}
+//# sourceMappingURL=sessions.service.d.ts.map

package/dist/modules/sessions/sessions.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sessions.service.d.ts","sourceRoot":"","sources":["../../../src/modules/sessions/sessions.service.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,4BAA4B,EACjC,KAAK,2BAA2B,EAChC,qBAAqB,EACtB,MAAM,aAAa,CAAC;AAQrB,OAAO,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAC/C,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AACtD,OAAO,EAAE,2BAA2B,EAAE,MAAM,sEAAsE,CAAC;AACnH,OAAO,EAAE,KAAK,gBAAgB,EAAE,MAAM,6BAA6B,CAAC;AACpE,OAAO,EAAE,KAAK,gBAAgB,EAAE,MAAM,6BAA6B,CAAC;AACpE,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAClE,OAAO,EAAE,uBAAuB,EAAE,MAAM,wCAAwC,CAAC;AAEjF,qBACa,eAAe;IAExB,OAAO,CAAC,QAAQ,CAAC,cAAc;IAC/B,OAAO,CAAC,QAAQ,CAAC,aAAa;IAC9B,OAAO,CAAC,QAAQ,CAAC,uBAAuB;IACxC,OAAO,CAAC,QAAQ,CAAC,WAAW;IAChB,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAC;gBAJxB,cAAc,EAAE,qBAAqB,EACrC,aAAa,EAAE,aAAa,EAC5B,uBAAuB,EAAE,uBAAuB,EAChD,WAAW,EAAE,2BAA2B,EAC5B,WAAW,CAAC,EAAE,WAAW,YAAA;IAGlD,6BAA6B,CAAC,IAAI,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC;IAgCpE,aAAa,CACjB,IAAI,EAAE,gBAAgB,GACrB,OAAO,CAAC,4BAA4B,CAAC;IA0ClC,YAAY,CAChB,IAAI,EAAE,eAAe,GACpB,OAAO,CAAC,2BAA2B,CAAC;IAwCjC,aAAa,CAAC,IAAI,EAAE,gBAAgB,GAAG,OAAO,CAAC;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;CA4C1E"}

package/dist/modules/sessions/sessions.service.js

@@ -0,0 +1,168 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { SessionManagerService, } from '@ixo/common';
+import { getMatrixHomeServerCroppedForDid } from '@ixo/oracles-chain-client';
+import { BadRequestException, Injectable, Logger, Optional, } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import { UcanService } from '../ucan/ucan.service.js';
+import { UserMatrixSqliteSyncService } from '../../matrix/checkpointer/user-matrix-sqlite-sync-service.service.js';
+import { SessionHistoryProcessor } from './session-history-processor.service.js';
+let SessionsService = class SessionsService {
+    sessionManager;
+    configService;
+    sessionHistoryProcessor;
+    syncService;
+    ucanService;
+    constructor(sessionManager, configService, sessionHistoryProcessor, syncService, ucanService) {
+        this.sessionManager = sessionManager;
+        this.configService = configService;
+        this.sessionHistoryProcessor = sessionHistoryProcessor;
+        this.syncService = syncService;
+        this.ucanService = ucanService;
+    }
+    async processPreviousSessionHistory(data) {
+        const oracleEntityDid = this.configService.getOrThrow('ORACLE_ENTITY_DID');
+        const { sessions } = await this.listSessions({
+            did: data.did,
+        });
+        const previousSession = sessions[0]; // most recent
+        if (previousSession) {
+            // Guard the inner fire-and-forget separately — the outer guard on
+            // processPreviousSessionHistory drops when this method resolves,
+            // but processSessionHistory continues running in the background.
+            this.syncService.markUserActive(data.did);
+            this.sessionHistoryProcessor
+                .processSessionHistory({
+                sessionId: previousSession.sessionId,
+                did: data.did,
+                oracleEntityDid,
+                homeServer: data.homeServer,
+            })
+                .catch((err) => Logger.error(`Failed to process previous session ${previousSession.sessionId}:`, err))
+                .finally(() => {
+                this.syncService.markUserInactive(data.did);
+            });
+        }
+    }
+    async createSession(data) {
+        this.syncService.markUserActive(data.did);
+        try {
+            const oracleEntityDid = this.configService.getOrThrow('ORACLE_ENTITY_DID');
+            // Increment ref count BEFORE firing the background task so the outer
+            // finally's markUserInactive doesn't drop to 0 while the task runs.
+            this.syncService.markUserActive(data.did);
+            this.processPreviousSessionHistory(data)
+                .catch((err) => Logger.error(`Failed to process previous session history for DID ${data.did}:`, err))
+                .finally(() => {
+                this.syncService.markUserInactive(data.did);
+            });
+            const session = await this.sessionManager.createSession({
+                did: data.did,
+                homeServer: data.homeServer,
+                oracleName: this.configService.getOrThrow('ORACLE_NAME'),
+                oracleEntityDid,
+                oracleDid: this.configService.getOrThrow('ORACLE_DID'),
+                slackThreadTs: data.slackThreadTs,
+            });
+            return session;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            const stack = error instanceof Error ? error.stack : undefined;
+            Logger.error(`Failed to create session for DID ${data.did}: ${message}`, stack);
+            throw new BadRequestException(`Session creation failed: ${message}`);
+        }
+        finally {
+            this.syncService.markUserInactive(data.did);
+        }
+    }
+    async listSessions(data) {
+        this.syncService.markUserActive(data.did);
+        try {
+            // Resolve the user's main room so we only return main-room sessions.
+            // Task-room sessions (created via Matrix in dedicated task channels)
+            // are filtered out — the portal only shows main conversations.
+            const userHomeServer = data.homeServer || (await getMatrixHomeServerCroppedForDid(data.did));
+            const { roomId: mainRoomId } = await this.sessionManager.matrixManger.getOracleRoomIdWithHomeServer({
+                userDid: data.did,
+                oracleEntityDid: this.configService.getOrThrow('ORACLE_ENTITY_DID'),
+                userHomeServer,
+            });
+            const sessionsResult = await this.sessionManager.listSessions({
+                did: data.did,
+                oracleEntityDid: this.configService.getOrThrow('ORACLE_ENTITY_DID'),
+                limit: data.limit ?? 20,
+                offset: data.offset ?? 0,
+                roomId: mainRoomId ?? undefined,
+            });
+            return {
+                sessions: sessionsResult.sessions,
+                total: sessionsResult.total,
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            const stack = error instanceof Error ? error.stack : undefined;
+            Logger.error(`Failed to list sessions for DID ${data.did}: ${message}`, stack);
+            throw new BadRequestException(`Failed to list sessions: ${message}`);
+        }
+        finally {
+            this.syncService.markUserInactive(data.did);
+        }
+    }
+    async deleteSession(data) {
+        this.syncService.markUserActive(data.did);
+        try {
+            const oracleEntityDid = this.configService.getOrThrow('ORACLE_ENTITY_DID');
+            // Increment ref count BEFORE firing the background task so the outer
+            // finally's markUserInactive doesn't drop to 0 while the task runs.
+            this.syncService.markUserActive(data.did);
+            this.sessionHistoryProcessor
+                .processSessionHistory({
+                sessionId: data.sessionId,
+                did: data.did,
+                oracleEntityDid,
+                homeServer: data.homeServer,
+            })
+                .catch((err) => Logger.error(`Failed to process deleted session ${data.sessionId}:`, err))
+                .finally(() => {
+                this.syncService.markUserInactive(data.did);
+            });
+            await this.sessionManager.deleteSession({
+                did: data.did,
+                sessionId: data.sessionId,
+                oracleEntityDid,
+            });
+            return { message: 'Session deleted successfully' };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            const stack = error instanceof Error ? error.stack : undefined;
+            Logger.error(`Failed to delete session ${data.sessionId} for DID ${data.did}: ${message}`, stack);
+            throw new BadRequestException(`Failed to delete session: ${message}`);
+        }
+        finally {
+            this.syncService.markUserInactive(data.did);
+        }
+    }
+};
+SessionsService = __decorate([
+    Injectable(),
+    __param(4, Optional()),
+    __metadata("design:paramtypes", [SessionManagerService,
+        ConfigService,
+        SessionHistoryProcessor,
+        UserMatrixSqliteSyncService,
+        UcanService])
+], SessionsService);
+export { SessionsService };