@ixo/oracle-runtime 0.0.1

package/dist/modules/messages/homeserver-cache.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Per-DID Matrix home-server cache. `getMatrixHomeServerCroppedForDid` does a
+ * chain-side lookup; the result is stable per user for the lifetime of their
+ * Matrix account, so a 1h TTL is conservative. Saves 50-200ms per request
+ * after the first warm-up.
+ */
+export declare class HomeServerCache {
+    private readonly cache;
+    get(userDid: string): Promise<string>;
+}
+//# sourceMappingURL=homeserver-cache.d.ts.map

package/dist/modules/messages/homeserver-cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"homeserver-cache.d.ts","sourceRoot":"","sources":["../../../src/modules/messages/homeserver-cache.ts"],"names":[],"mappings":"AAUA;;;;;GAKG;AACH,qBACa,eAAe;IAC1B,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAiC;IAEjD,GAAG,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;CAS5C"}

package/dist/modules/messages/homeserver-cache.js

@@ -0,0 +1,31 @@
+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 { getMatrixHomeServerCroppedForDid } from '@ixo/oracles-chain-client';
+import { Injectable } from '@nestjs/common';
+const TTL_MS = 60 * 60 * 1000;
+/**
+ * Per-DID Matrix home-server cache. `getMatrixHomeServerCroppedForDid` does a
+ * chain-side lookup; the result is stable per user for the lifetime of their
+ * Matrix account, so a 1h TTL is conservative. Saves 50-200ms per request
+ * after the first warm-up.
+ */
+let HomeServerCache = class HomeServerCache {
+    cache = new Map();
+    async get(userDid) {
+        const cached = this.cache.get(userDid);
+        if (cached && cached.expiresAt > Date.now()) {
+            return cached.homeServer;
+        }
+        const homeServer = await getMatrixHomeServerCroppedForDid(userDid);
+        this.cache.set(userDid, { homeServer, expiresAt: Date.now() + TTL_MS });
+        return homeServer;
+    }
+};
+HomeServerCache = __decorate([
+    Injectable()
+], HomeServerCache);
+export { HomeServerCache };

package/dist/modules/messages/matrix-listener-bridge.d.ts

@@ -0,0 +1,63 @@
+import { SessionManagerService } from '@ixo/common';
+import { type OnModuleDestroy, type OnModuleInit } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+export interface MatrixIncomingMessage {
+    did: string;
+    message: string;
+    threadId: string;
+    langchainThreadId?: string;
+    roomId: string;
+    homeServer?: string;
+    /** Sender's full Matrix user id (e.g. `@alice:matrix.example`). */
+    senderMatrixUserId?: string;
+    /** Matrix event id of the latest text event being delivered. */
+    eventId?: string;
+    /** Raw `m.mentions` payload from the event, if present. */
+    mentions?: {
+        user_ids?: string[];
+    };
+    /** Raw `m.relates_to` payload from the event, if present. */
+    relatesTo?: {
+        'm.in_reply_to'?: {
+            event_id: string;
+        };
+    };
+    attachments?: Array<{
+        eventId: string;
+        filename: string;
+        mimetype: string;
+        size?: number;
+    }>;
+}
+/**
+ * Bridges Matrix room events into chat turns. Handles:
+ *
+ *   - Ignoring own (oracle) messages and INTERNAL events
+ *   - Thread-root resolution with caching (a Matrix reply chain → session)
+ *   - Per-thread debounce so text + file pairs land as one turn
+ *   - Session bootstrap when the sender doesn't have one yet
+ *
+ * The bridge owns the listener registration. The caller (MessagesService)
+ * supplies a callback that turns a debounced thread batch into a chat
+ * invocation — this keeps the bridge ignorant of the runtime/graph layer.
+ */
+export declare class MatrixListenerBridge implements OnModuleInit, OnModuleDestroy {
+    private readonly sessions;
+    private readonly config;
+    private readonly logger;
+    private cleanUpListener?;
+    private readonly threadRootCache;
+    private readonly buffer;
+    private readonly matrixManager;
+    private deliverHandler;
+    constructor(sessions: SessionManagerService, config: ConfigService);
+    /** Register the callback invoked once a debounced thread batch is ready. */
+    setDeliverHandler(handler: (msg: MatrixIncomingMessage) => Promise<unknown>): void;
+    onModuleInit(): void;
+    onModuleDestroy(): void;
+    private handleMessage;
+    private ensureSession;
+    private flush;
+    private getThreadRoot;
+}
+//# sourceMappingURL=matrix-listener-bridge.d.ts.map

package/dist/modules/messages/matrix-listener-bridge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"matrix-listener-bridge.d.ts","sourceRoot":"","sources":["../../../src/modules/messages/matrix-listener-bridge.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAoB,MAAM,aAAa,CAAC;AAMtE,OAAO,EAGL,KAAK,eAAe,EACpB,KAAK,YAAY,EAClB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AA0B/C,MAAM,WAAW,qBAAqB;IACpC,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,mEAAmE;IACnE,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,gEAAgE;IAChE,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,2DAA2D;IAC3D,QAAQ,CAAC,EAAE;QAAE,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC;IACnC,6DAA6D;IAC7D,SAAS,CAAC,EAAE;QAAE,eAAe,CAAC,EAAE;YAAE,QAAQ,EAAE,MAAM,CAAA;SAAE,CAAA;KAAE,CAAC;IACvD,WAAW,CAAC,EAAE,KAAK,CAAC;QAClB,OAAO,EAAE,MAAM,CAAC;QAChB,QAAQ,EAAE,MAAM,CAAC;QACjB,QAAQ,EAAE,MAAM,CAAC;QACjB,IAAI,CAAC,EAAE,MAAM,CAAC;KACf,CAAC,CAAC;CACJ;AAED;;;;;;;;;;;GAWG;AACH,qBACa,oBAAqB,YAAW,YAAY,EAAE,eAAe;IAWtE,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,MAAM;IAXzB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAyC;IAChE,OAAO,CAAC,eAAe,CAAC,CAAa;IACrC,OAAO,CAAC,QAAQ,CAAC,eAAe,CAA6B;IAC7D,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAkC;IACzD,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAgB;IAC9C,OAAO,CAAC,cAAc,CAEN;gBAGG,QAAQ,EAAE,qBAAqB,EAC/B,MAAM,EAAE,aAAa;IAKxC,4EAA4E;IAC5E,iBAAiB,CACf,OAAO,EAAE,CAAC,GAAG,EAAE,qBAAqB,KAAK,OAAO,CAAC,OAAO,CAAC,GACxD,IAAI;IAIP,YAAY,IAAI,IAAI;IAgBpB,eAAe,IAAI,IAAI;YAMT,aAAa;YAkDb,aAAa;YAqCb,KAAK;YAuGL,aAAa;CAiD5B"}

package/dist/modules/messages/matrix-listener-bridge.js

@@ -0,0 +1,280 @@
+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 MatrixListenerBridge_1;
+import { SessionManagerService } from '@ixo/common';
+import { Injectable, Logger, } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+const FILE_MSGTYPES = new Set(['m.file', 'm.image', 'm.video', 'm.audio']);
+const DEBOUNCE_MS = 500;
+/**
+ * Bridges Matrix room events into chat turns. Handles:
+ *
+ *   - Ignoring own (oracle) messages and INTERNAL events
+ *   - Thread-root resolution with caching (a Matrix reply chain → session)
+ *   - Per-thread debounce so text + file pairs land as one turn
+ *   - Session bootstrap when the sender doesn't have one yet
+ *
+ * The bridge owns the listener registration. The caller (MessagesService)
+ * supplies a callback that turns a debounced thread batch into a chat
+ * invocation — this keeps the bridge ignorant of the runtime/graph layer.
+ */
+let MatrixListenerBridge = MatrixListenerBridge_1 = class MatrixListenerBridge {
+    sessions;
+    config;
+    logger = new Logger(MatrixListenerBridge_1.name);
+    cleanUpListener;
+    threadRootCache = new Map();
+    buffer = new Map();
+    matrixManager;
+    deliverHandler = null;
+    constructor(sessions, config) {
+        this.sessions = sessions;
+        this.config = config;
+        this.matrixManager = this.sessions.matrixManger;
+    }
+    /** Register the callback invoked once a debounced thread batch is ready. */
+    setDeliverHandler(handler) {
+        this.deliverHandler = handler;
+    }
+    onModuleInit() {
+        this.matrixManager
+            .init()
+            .then(() => {
+            this.cleanUpListener = this.matrixManager.onMessage((roomId, event) => {
+                this.handleMessage(event, roomId).catch((err) => this.logger.error('Matrix listener failed', err));
+            });
+            this.logger.log('Matrix message listener registered');
+        })
+            .catch((err) => this.logger.error('Failed to set up Matrix listener', err));
+    }
+    onModuleDestroy() {
+        for (const [, entry] of this.buffer)
+            clearTimeout(entry.timer);
+        this.buffer.clear();
+        this.cleanUpListener?.();
+    }
+    async handleMessage(event, roomId) {
+        const did = normalizeDid(event.sender);
+        const oracleDid = this.config.getOrThrow('ORACLE_DID');
+        if (did === oracleDid)
+            return;
+        if ('INTERNAL' in event.content)
+            return;
+        const msgtype = event.content.msgtype;
+        const isText = msgtype === 'm.text' &&
+            'body' in event.content &&
+            typeof event.content.body === 'string';
+        const isFile = typeof msgtype === 'string' && FILE_MSGTYPES.has(msgtype);
+        if (!isText && !isFile)
+            return;
+        const threadId = await this.getThreadRoot(event, roomId);
+        if (!threadId) {
+            this.logger.warn(`No thread root for eventId=${event.eventId} roomId=${roomId}`);
+            return;
+        }
+        const threadEv = await this.matrixManager.getEventById(roomId, threadId);
+        const langchainThreadId = threadEv.content
+            ?.sessionId;
+        const sessionId = threadId;
+        await this.ensureSession(did, sessionId, event, roomId);
+        const existing = this.buffer.get(threadId);
+        if (existing) {
+            clearTimeout(existing.timer);
+            existing.events.push({ event, roomId });
+        }
+        else {
+            this.buffer.set(threadId, {
+                events: [{ event, roomId }],
+                timer: null,
+            });
+        }
+        const entry = this.buffer.get(threadId);
+        entry.timer = setTimeout(() => {
+            this.flush(threadId, langchainThreadId).catch((err) => this.logger.error(`Flush failed for thread ${threadId}`, err));
+        }, DEBOUNCE_MS);
+    }
+    async ensureSession(did, sessionId, event, roomId) {
+        let hasSession;
+        try {
+            hasSession = await this.sessions.getSession(sessionId, did, false);
+        }
+        catch (err) {
+            this.logger.error(`Error checking session did=${did} sessionId=${sessionId}`, err);
+        }
+        if (hasSession)
+            return;
+        const userHomeServer = event.sender.split(':').slice(1).join(':');
+        try {
+            await this.sessions.createSession({
+                did,
+                oracleDid: this.config.getOrThrow('ORACLE_DID'),
+                oracleEntityDid: this.config.getOrThrow('ORACLE_ENTITY_DID'),
+                oracleName: this.config.getOrThrow('ORACLE_NAME'),
+                homeServer: userHomeServer,
+                roomId,
+            }, event.eventId);
+        }
+        catch (err) {
+            this.logger.error(`createSession failed did=${did}`, err);
+            throw err;
+        }
+    }
+    async flush(threadId, langchainThreadId) {
+        const entry = this.buffer.get(threadId);
+        if (!entry)
+            return;
+        this.buffer.delete(threadId);
+        const first = entry.events[0];
+        if (!first)
+            return;
+        const did = normalizeDid(first.event.sender);
+        const homeServer = first.event.sender.split(':')[1];
+        let text;
+        let latestTextEvent;
+        const attachments = [];
+        for (const { event } of entry.events) {
+            const msgtype = event.content.msgtype;
+            if (msgtype === 'm.text' &&
+                'body' in event.content &&
+                typeof event.content.body === 'string') {
+                text = event.content.body;
+                latestTextEvent = event;
+            }
+            else if (typeof msgtype === 'string' && FILE_MSGTYPES.has(msgtype)) {
+                attachments.push(buildAttachment(event));
+            }
+        }
+        // Speaker + threading metadata for the downstream HumanMessage. Use the
+        // latest text event when available (so mentions / replies refer to the
+        // user-visible message), otherwise fall back to the first event in the
+        // batch (file-only sends).
+        const sourceEvent = latestTextEvent ?? first.event;
+        this.logger.debug(`flush sourceEvent eventId=${sourceEvent.eventId} sender=${sourceEvent.sender}`);
+        const senderMatrixUserId = sourceEvent.sender;
+        const eventId = sourceEvent.eventId;
+        const sourceContent = sourceEvent.content;
+        const mentions = sourceContent['m.mentions'];
+        const relatesTo = sourceContent['m.relates_to'];
+        const message = text ??
+            (attachments.length === 1
+                ? `User shared a file: ${attachments[0]?.filename ?? 'file'}`
+                : `User shared ${attachments.length} file(s): ${attachments.map((a) => a.filename).join(', ')}`);
+        if (!this.deliverHandler) {
+            this.logger.warn('MatrixListenerBridge.flush: deliverHandler not set; dropping message');
+            return;
+        }
+        try {
+            const aiResponse = (await this.deliverHandler({
+                did,
+                message,
+                threadId,
+                langchainThreadId,
+                roomId: first.roomId,
+                homeServer,
+                senderMatrixUserId,
+                eventId,
+                ...(mentions && { mentions }),
+                ...(relatesTo && { relatesTo }),
+                ...(attachments.length > 0 && { attachments }),
+            }));
+            if (!aiResponse) {
+                this.logger.warn(`No AI response returned for threadId=${threadId}`);
+                return;
+            }
+            // The BatchInvoker returns whatever lives at the tail of graph state.
+            // When a `beforeAgent` middleware short-circuits with `jumpTo: 'end'`
+            // (e.g. the group-chat gate ignoring an un-mentioned room message),
+            // no AI message is produced and the tail is the user's own
+            // HumanMessage. Posting that back would echo the user to themselves
+            // with the speaker-prefix applied.
+            if (aiResponse.message.type !== 'ai') {
+                this.logger.log(`Skipping Matrix reply for threadId=${threadId} — agent did not produce an AI message (tail type=${aiResponse.message.type})`);
+                return;
+            }
+            await this.matrixManager.sendMessage({
+                message: aiResponse.message.content,
+                roomId: first.roomId,
+                threadId,
+                isOracleAdmin: true,
+                disablePrefix: true,
+            });
+        }
+        catch (error) {
+            this.logger.error('Failed to handle Matrix message', error);
+        }
+    }
+    async getThreadRoot(event, roomId) {
+        const eventId = event.eventId;
+        if (!eventId)
+            return undefined;
+        const inReplyTo = event.content['m.relates_to']?.['m.in_reply_to']?.event_id;
+        if (!inReplyTo) {
+            this.threadRootCache.set(eventId, eventId);
+            return eventId;
+        }
+        if (this.threadRootCache.has(inReplyTo)) {
+            const root = this.threadRootCache.get(inReplyTo);
+            if (!root)
+                return undefined;
+            this.threadRootCache.set(eventId, root);
+            return root;
+        }
+        const pathToCache = [eventId];
+        let cursor = inReplyTo;
+        const visited = new Set();
+        while (cursor && !visited.has(cursor)) {
+            visited.add(cursor);
+            pathToCache.push(cursor);
+            if (this.threadRootCache.has(cursor)) {
+                const root = this.threadRootCache.get(cursor);
+                if (!root)
+                    return undefined;
+                pathToCache.forEach((id) => this.threadRootCache.set(id, root));
+                return root;
+            }
+            const parent = await this.matrixManager.getEventById(roomId, cursor);
+            const parentReply = parent.content['m.relates_to']?.['m.in_reply_to']?.event_id;
+            if (!parentReply) {
+                pathToCache.forEach((id) => this.threadRootCache.set(id, cursor));
+                return cursor;
+            }
+            cursor = parentReply;
+        }
+        const fallback = cursor || eventId;
+        pathToCache.forEach((id) => this.threadRootCache.set(id, fallback));
+        return fallback;
+    }
+};
+MatrixListenerBridge = MatrixListenerBridge_1 = __decorate([
+    Injectable(),
+    __metadata("design:paramtypes", [SessionManagerService,
+        ConfigService])
+], MatrixListenerBridge);
+export { MatrixListenerBridge };
+function normalizeDid(input) {
+    const username = input.split(':')[0] ?? '';
+    const parts = username.split('-');
+    if (parts.length < 3 || parts[0] !== '@did') {
+        throw new Error(`Invalid DID format: ${input}`);
+    }
+    const namespace = parts[1];
+    const identifier = parts.slice(2).join('-');
+    return `did:${namespace}:${identifier}`;
+}
+function buildAttachment(event) {
+    const content = event.content;
+    const info = content.info;
+    return {
+        eventId: event.eventId,
+        filename: content.filename ?? content.body ?? 'file',
+        mimetype: info?.mimetype ?? 'application/octet-stream',
+        size: info?.size,
+    };
+}

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

@@ -0,0 +1,13 @@
+import type { Request, Response } from 'express';
+import { AbortRequestDto, SendMessageDto } from './dto/send-message.dto.js';
+import { MessagesService } from './messages.service.js';
+export declare class MessagesController {
+    private readonly messagesService;
+    constructor(messagesService: MessagesService);
+    abortRequest(abortRequestDto: AbortRequestDto): Promise<{
+        success: boolean;
+    }>;
+    listMessages(req: Request, sessionId: string): Promise<import("@ixo/common").ListOracleMessagesResponse>;
+    sendMessage(req: Request, sendMessageDto: SendMessageDto, sessionId: string, res: Response): Promise<Response<any, Record<string, any>> | undefined>;
+}
+//# sourceMappingURL=messages.controller.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"messages.controller.d.ts","sourceRoot":"","sources":["../../../src/modules/messages/messages.controller.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACjD,OAAO,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAC5E,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAExD,qBAEa,kBAAkB;IACjB,OAAO,CAAC,QAAQ,CAAC,eAAe;gBAAf,eAAe,EAAE,eAAe;IAMvD,YAAY,CAAS,eAAe,EAAE,eAAe;;;IAarD,YAAY,CACT,GAAG,EAAE,OAAO,EACC,SAAS,EAAE,MAAM;IAYjC,WAAW,CACR,GAAG,EAAE,OAAO,EACX,cAAc,EAAE,cAAc,EAClB,SAAS,EAAE,MAAM,EAC9B,GAAG,EAAE,QAAQ;CAwBvB"}

package/dist/modules/messages/messages.controller.js

@@ -0,0 +1,95 @@
+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 { Body, Controller, Get, HttpCode, HttpStatus, Param, Post, Req, Res, } from '@nestjs/common';
+import { ApiOperation, ApiParam, ApiResponse, ApiTags } from '@nestjs/swagger';
+import { AbortRequestDto, SendMessageDto } from './dto/send-message.dto.js';
+import { MessagesService } from './messages.service.js';
+let MessagesController = class MessagesController {
+    messagesService;
+    constructor(messagesService) {
+        this.messagesService = messagesService;
+    }
+    async abortRequest(abortRequestDto) {
+        const success = this.messagesService.abortRequest(abortRequestDto.sessionId);
+        return { success };
+    }
+    async listMessages(req, sessionId) {
+        const { did } = req.authData;
+        return this.messagesService.listMessages({ sessionId, did });
+    }
+    async sendMessage(req, sendMessageDto, sessionId, res) {
+        const { did, ucanDelegation } = req.authData;
+        const payload = {
+            ...sendMessageDto,
+            did,
+            sessionId,
+            ucanDelegation,
+        };
+        if (sendMessageDto.stream) {
+            // SSE headers are set inside `SseStreamRunner` *after* prepareForQuery
+            // resolves the requestId — that lets us include `X-Request-Id` in the
+            // response and the matching `Access-Control-Expose-Headers` so the FE
+            // can read it. The earlier "flush before pre-flight" optimization
+            // dropped those headers and broke FE clients that expect them.
+            await this.messagesService.sendMessage({ ...payload, res, req });
+            // The service ends the response in its `finally` — nothing to return.
+            return;
+        }
+        const result = await this.messagesService.sendMessage({ ...payload, req });
+        return res.status(HttpStatus.OK).json(result);
+    }
+};
+__decorate([
+    Post('abort'),
+    HttpCode(HttpStatus.OK),
+    ApiOperation({ summary: 'Abort an ongoing stream request' }),
+    ApiResponse({ status: 200, description: 'Request aborted successfully.' }),
+    __param(0, Body()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [AbortRequestDto]),
+    __metadata("design:returntype", Promise)
+], MessagesController.prototype, "abortRequest", null);
+__decorate([
+    Get(':sessionId'),
+    ApiOperation({ summary: 'List messages in a session' }),
+    ApiParam({ name: 'sessionId', required: true }),
+    ApiResponse({ status: 200, description: 'Messages retrieved successfully.' }),
+    ApiResponse({ status: 400, description: 'Bad Request.' }),
+    ApiResponse({ status: 404, description: 'Room not found.' }),
+    __param(0, Req()),
+    __param(1, Param('sessionId')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, String]),
+    __metadata("design:returntype", Promise)
+], MessagesController.prototype, "listMessages", null);
+__decorate([
+    Post(':sessionId'),
+    HttpCode(HttpStatus.OK),
+    ApiOperation({ summary: 'Send a message to the oracle' }),
+    ApiParam({ name: 'sessionId', required: true }),
+    ApiResponse({ status: 200, description: 'Message sent successfully.' }),
+    ApiResponse({ status: 400, description: 'Bad Request.' }),
+    __param(0, Req()),
+    __param(1, Body()),
+    __param(2, Param('sessionId')),
+    __param(3, Res()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, SendMessageDto, String, Object]),
+    __metadata("design:returntype", Promise)
+], MessagesController.prototype, "sendMessage", null);
+MessagesController = __decorate([
+    ApiTags('messages'),
+    Controller('messages'),
+    __metadata("design:paramtypes", [MessagesService])
+], MessagesController);
+export { MessagesController };

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

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

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

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

package/dist/modules/messages/messages.module.js

@@ -0,0 +1,75 @@
+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 { CheckpointStorageSyncModule } from '../../matrix/checkpointer/user-matrix-sqlite-sync-service.module.js';
+import { UserMatrixSqliteSyncService } from '../../matrix/checkpointer/user-matrix-sqlite-sync-service.service.js';
+import { UcanModule } from '../ucan/ucan.module.js';
+import { AgentBuilder } from './agent-builder.js';
+import { BatchInvoker } from './batch-invoker.js';
+import { FileProcessingService } from './file-processing.service.js';
+import { HomeServerCache } from './homeserver-cache.js';
+import { MatrixListenerBridge } from './matrix-listener-bridge.js';
+import { MessagesController } from './messages.controller.js';
+import { MessagesService } from './messages.service.js';
+import { OracleRuntimeBundleHolder } from './oracle-runtime-bundle.js';
+import { PostMessageSyncer } from './post-message-syncer.js';
+import { RequestPreparer } from './request-preparer.js';
+import { SseStreamRunner } from './sse-stream-runner.js';
+import { UserContextFetcher } from './user-context-fetcher.js';
+let MessagesModule = class MessagesModule {
+};
+MessagesModule = __decorate([
+    Module({
+        imports: [CheckpointStorageSyncModule, UcanModule],
+        controllers: [MessagesController],
+        providers: [
+            MessagesService,
+            FileProcessingService,
+            OracleRuntimeBundleHolder,
+            HomeServerCache,
+            RequestPreparer,
+            AgentBuilder,
+            SseStreamRunner,
+            UserContextFetcher,
+            BatchInvoker,
+            PostMessageSyncer,
+            MatrixListenerBridge,
+            {
+                // `MemoryEngineService` is OPTIONAL. `UserContextFetcher` reads it
+                // each turn (cached for 3 min) to populate `state.userContext`
+                // before the agent is built. When `MEMORY_ENGINE_URL` isn't set,
+                // we provide `null` and the fetcher returns `undefined`. The memory
+                // plugin still gates its OWN tool surface via `autoDetect`/`configSchema`.
+                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: [
+            MessagesService,
+            MemoryEngineService,
+            SessionManagerService,
+            OracleRuntimeBundleHolder,
+        ],
+    })
+], MessagesModule);
+export { MessagesModule };