@amalgm/chat 0.1.1 → 0.2.0

package/dist/sessions/chat.js

@@ -0,0 +1,701 @@
+import { applyAcpTranscriptUpdate, createAcpTranscriptState, finalizeAcpTranscript, } from '../conversations/transcript.js';
+import { normalizePrompt } from '../input/prompt.js';
+import { normalizeExecutionContract } from '../execution/contract.js';
+import { executionRevision } from '../execution/revision.js';
+import { PreparedExecutionStore } from '../execution/store.js';
+export class SessionNotFoundError extends Error {
+    code = 'SESSION_NOT_FOUND';
+    constructor(sessionId) {
+        super(`Session not found: ${sessionId}`);
+        this.name = 'SessionNotFoundError';
+    }
+}
+export class SessionAlreadyExistsError extends Error {
+    code = 'SESSION_ALREADY_EXISTS';
+    constructor(sessionId) {
+        super(`Session already exists: ${sessionId}`);
+        this.name = 'SessionAlreadyExistsError';
+    }
+}
+export class SessionBusyError extends Error {
+    code = 'SESSION_BUSY';
+    constructor(sessionId) {
+        super(`Session already has an active turn: ${sessionId}`);
+        this.name = 'SessionBusyError';
+    }
+}
+export class SessionAgentMismatchError extends Error {
+    code = 'SESSION_AGENT_MISMATCH';
+    constructor(sessionId) {
+        super(`Session belongs to a different agent installation: ${sessionId}`);
+        this.name = 'SessionAgentMismatchError';
+    }
+}
+export class TurnStreamError extends Error {
+    code;
+    turn;
+    constructor(turn) {
+        const stored = turn.error;
+        super(typeof stored?.['message'] === 'string' ? stored['message'] : `Turn ${turn.status}: ${turn.id}`);
+        this.name = 'TurnStreamError';
+        this.code = typeof stored?.['code'] === 'string' ? stored['code'] : `TURN_${turn.status.toUpperCase()}`;
+        this.turn = turn;
+    }
+}
+export class SubscriberBackpressureError extends Error {
+    code = 'SUBSCRIBER_BACKPRESSURE';
+    constructor(turnId) {
+        super(`Subscriber fell behind the durable turn journal: ${turnId}`);
+        this.name = 'SubscriberBackpressureError';
+    }
+}
+export class InterruptUnsupportedError extends Error {
+    code = 'INTERRUPT_UNSUPPORTED';
+    constructor(sessionId) {
+        super(`Runtime cannot interrupt the active turn: ${sessionId}`);
+        this.name = 'InterruptUnsupportedError';
+    }
+}
+class LiveTurnBuffer {
+    #turnId;
+    #limit;
+    #updates = new Map();
+    #terminal = null;
+    #failure = null;
+    #wake = null;
+    constructor(turnId, limit) {
+        this.#turnId = turnId;
+        this.#limit = limit;
+    }
+    offer(update, afterSequence) {
+        if (update.sequence <= afterSequence || this.#failure)
+            return;
+        this.#updates.set(update.sequence, update);
+        if (this.#updates.size > this.#limit) {
+            this.#failure = new SubscriberBackpressureError(this.#turnId);
+        }
+        this.#notify();
+    }
+    finish(turn) {
+        this.#terminal = turn;
+        this.#notify();
+    }
+    fail(error) {
+        this.#failure = error;
+        this.#notify();
+    }
+    takeAfter(afterSequence) {
+        let selected = null;
+        for (const update of this.#updates.values()) {
+            if (update.sequence <= afterSequence) {
+                this.#updates.delete(update.sequence);
+                continue;
+            }
+            if (!selected || update.sequence < selected.sequence)
+                selected = update;
+        }
+        if (selected)
+            this.#updates.delete(selected.sequence);
+        return selected;
+    }
+    get terminal() {
+        return this.#terminal;
+    }
+    get failure() {
+        return this.#failure;
+    }
+    wait() {
+        if (this.#failure || this.#terminal || this.#updates.size > 0)
+            return Promise.resolve();
+        return new Promise((resolve) => { this.#wake = resolve; });
+    }
+    #notify() {
+        const wake = this.#wake;
+        this.#wake = null;
+        wake?.();
+    }
+}
+function nonEmpty(value, label) {
+    if (typeof value !== 'string' || !value.trim())
+        throw new TypeError(`${label} must be a non-empty string`);
+    return value.trim();
+}
+function cleanTitle(value) {
+    const title = typeof value === 'string' ? value.replace(/\s+/g, ' ').trim() : '';
+    return title || 'New session';
+}
+function cleanCursor(value) {
+    return Number.isFinite(value) ? Math.max(0, Math.floor(value)) : 0;
+}
+function errorRecord(error, code = 'TURN_FAILED') {
+    if (error instanceof Error) {
+        const ownCode = error.code;
+        return Object.freeze({
+            code: typeof ownCode === 'string' && ownCode ? ownCode : code,
+            message: error.message,
+            name: error.name,
+        });
+    }
+    return Object.freeze({ code, message: String(error) });
+}
+function jsonCheckpoint(value) {
+    if (value === undefined || value === null)
+        return null;
+    try {
+        return JSON.parse(JSON.stringify(value));
+    }
+    catch {
+        return null;
+    }
+}
+function durableUpdate(update, stored) {
+    const source = update;
+    const meta = source['_meta'] && typeof source['_meta'] === 'object' && !Array.isArray(source['_meta'])
+        ? source['_meta']
+        : {};
+    const existing = meta['amalgm'] && typeof meta['amalgm'] === 'object' && !Array.isArray(meta['amalgm'])
+        ? meta['amalgm']
+        : {};
+    return {
+        ...source,
+        _meta: {
+            ...meta,
+            amalgm: {
+                ...existing,
+                conversationId: stored.conversationId,
+                turnId: stored.turnId,
+                sequence: stored.sequence,
+            },
+        },
+    };
+}
+export class ChatTurnStream {
+    sessionId;
+    turnId;
+    completion;
+    #subscribe;
+    constructor(sessionId, turnId, completion, subscribe) {
+        this.sessionId = sessionId;
+        this.turnId = turnId;
+        this.completion = completion;
+        this.#subscribe = subscribe;
+    }
+    reconnect(afterSequence = 0) {
+        return this.#subscribe(cleanCursor(afterSequence));
+    }
+    [Symbol.asyncIterator]() {
+        return this.#subscribe(0)[Symbol.asyncIterator]();
+    }
+}
+export class ChatSession {
+    id;
+    #chat;
+    constructor(chat, id) {
+        this.#chat = chat;
+        this.id = id;
+    }
+    send(options) {
+        return this.#chat.send(this.id, options);
+    }
+    reconnect(turnId, options = {}) {
+        return this.#chat.reconnectTurn(this.id, turnId, options.afterSequence);
+    }
+    interrupt() {
+        return this.#chat.interruptSession(this.id);
+    }
+    inspect() {
+        return this.#chat.inspectSession(this.id);
+    }
+    messages() {
+        return this.#chat.listMessages(this.id);
+    }
+    updateTitle(title) {
+        return this.#chat.updateTitle(this.id, title);
+    }
+    close() {
+        return this.#chat.closeSession(this.id);
+    }
+}
+export class Chat {
+    #runtime;
+    #ownerUserId;
+    #conversations;
+    #uuid;
+    #clockIso;
+    #sha256Hex;
+    #executions;
+    #subscriberBufferSize;
+    #journalBatch;
+    #sessions = new Map();
+    #turns = new Map();
+    #subscribers = new Map();
+    constructor(options) {
+        this.#runtime = options.runtime;
+        this.#ownerUserId = nonEmpty(options.ownerUserId, 'ownerUserId');
+        this.#conversations = options.conversations;
+        this.#uuid = options.uuid;
+        this.#clockIso = options.clockIso;
+        this.#sha256Hex = options.sha256Hex;
+        this.#executions = options.executions ?? new PreparedExecutionStore();
+        this.#subscriberBufferSize = Number.isFinite(options.subscriberBufferSize)
+            ? Math.max(1, Math.floor(options.subscriberBufferSize))
+            : 1024;
+        this.#journalBatch = options.journalBatch;
+    }
+    /** Control-plane operation. Call while the user is composing, never from send. */
+    async prepareExecution(id, input) {
+        if (typeof id !== 'string' || !id.trim()) {
+            throw new TypeError('prepared execution id must be a non-empty string');
+        }
+        const contract = normalizeExecutionContract(input);
+        const revision = executionRevision(contract, this.#sha256Hex);
+        const current = this.#executions.current(id.trim());
+        if (current?.revision === revision)
+            return current;
+        const binding = await this.#runtime.prepareExecution(contract);
+        return this.#executions.publish({ id: id.trim(), revision, contract, binding });
+    }
+    async startSession(options) {
+        const execution = this.#executions.resolve(options.execution);
+        const sessionId = options.sessionId?.trim() || this.#uuid();
+        if (this.#sessions.has(sessionId))
+            throw new SessionAlreadyExistsError(sessionId);
+        const scope = this.#scope(execution);
+        await this.#conversations.createConversation({
+            ...scope,
+            id: sessionId,
+            agentRevisionId: execution.contract.agent.revisionId,
+            adapterId: execution.contract.agent.adapterId,
+            title: cleanTitle(options.title),
+            origin: options.origin?.trim() || null,
+            originId: options.originId?.trim() || null,
+            lastExecutionComputerId: execution.contract.computerId,
+            metadata: Object.freeze({ ...(options.metadata || {}) }),
+            createdAt: this.#clockIso(),
+        });
+        const runtimeSession = await this.#runtime.startSession({ sessionId, execution });
+        this.#sessions.set(sessionId, {
+            id: sessionId,
+            scope,
+            runtimeSession,
+            execution,
+            busyTurnId: null,
+        });
+        return new ChatSession(this, sessionId);
+    }
+    async resumeSession(options) {
+        const execution = this.#executions.resolve(options.execution);
+        const existing = this.#sessions.get(options.sessionId);
+        if (existing) {
+            this.#assertInstallation(existing.scope, execution, options.sessionId);
+            return new ChatSession(this, existing.id);
+        }
+        const scope = this.#scope(execution);
+        const conversation = await this.#conversations.getConversation(scope, options.sessionId);
+        if (!conversation)
+            throw new SessionNotFoundError(options.sessionId);
+        if (!this.#runtime.resumeSession)
+            throw new SessionNotFoundError(options.sessionId);
+        const [checkpoint, messages] = await Promise.all([
+            this.#conversations.getProviderCheckpoint(scope, options.sessionId, execution.revision),
+            this.#conversations.listMessages(scope, options.sessionId),
+        ]);
+        const runtimeSession = await this.#runtime.resumeSession({
+            sessionId: options.sessionId,
+            execution,
+            checkpoint: checkpoint?.checkpoint ?? null,
+            messages,
+        });
+        this.#sessions.set(options.sessionId, {
+            id: options.sessionId,
+            scope,
+            runtimeSession,
+            execution,
+            busyTurnId: null,
+        });
+        return new ChatSession(this, options.sessionId);
+    }
+    /** Restore a durable conversation using the exact execution of its latest turn. */
+    async resumeStoredSession(sessionId) {
+        const id = nonEmpty(sessionId, 'sessionId');
+        const active = this.#sessions.get(id);
+        if (active) {
+            const latestTurn = await this.#conversations.getLatestTurn(active.scope, id);
+            if (!latestTurn)
+                throw new SessionNotFoundError(id);
+            return Object.freeze({
+                session: new ChatSession(this, id),
+                execution: Object.freeze({ id: active.execution.id, revision: active.execution.revision }),
+                latestTurn,
+            });
+        }
+        const found = await this.#conversations.getConversationForOwner(this.#ownerUserId, id, true);
+        if (!found)
+            throw new SessionNotFoundError(id);
+        const latestTurn = await this.#conversations.getLatestTurn(found.scope, id);
+        if (!latestTurn)
+            throw new SessionNotFoundError(id);
+        const execution = await this.prepareExecution(`conversation:${id}`, latestTurn.execution);
+        const session = await this.resumeSession({ sessionId: id, execution });
+        return Object.freeze({ session, execution, latestTurn });
+    }
+    async send(sessionId, options) {
+        const record = this.#sessions.get(sessionId);
+        if (!record)
+            throw new SessionNotFoundError(sessionId);
+        if (record.busyTurnId)
+            throw new SessionBusyError(sessionId);
+        const execution = this.#executions.resolve(options.execution);
+        this.#assertInstallation(record.scope, execution, sessionId);
+        const prompt = normalizePrompt(options.prompt);
+        const turnId = options.clientTurnId === undefined
+            ? this.#uuid()
+            : nonEmpty(options.clientTurnId, 'clientTurnId');
+        const userMessageId = options.userMessageId === undefined
+            ? this.#uuid()
+            : nonEmpty(options.userMessageId, 'userMessageId');
+        const assistantMessageId = options.assistantMessageId === undefined
+            ? this.#uuid()
+            : nonEmpty(options.assistantMessageId, 'assistantMessageId');
+        await this.#conversations.beginTurn({
+            ...record.scope,
+            conversationId: sessionId,
+            turnId,
+            userMessageId,
+            prompt,
+            execution: execution.contract,
+            createdAt: this.#clockIso(),
+        });
+        record.busyTurnId = turnId;
+        this.#turns.set(turnId, {
+            conversationId: sessionId,
+            scope: record.scope,
+            execution,
+            phase: 'running',
+            interruptAccepted: false,
+            interruptAttempt: null,
+        });
+        const completion = this.#pumpTurn(record, turnId, assistantMessageId, prompt, execution);
+        void completion.catch(() => { });
+        return new ChatTurnStream(sessionId, turnId, completion, (afterSequence) => this.reconnectTurn(sessionId, turnId, afterSequence));
+    }
+    reconnectTurn(sessionId, turnId, afterSequence = 0) {
+        const record = this.#sessions.get(sessionId);
+        if (!record)
+            throw new SessionNotFoundError(sessionId);
+        const context = this.#turns.get(turnId) || {
+            conversationId: sessionId,
+            scope: record.scope,
+            execution: record.execution,
+            phase: 'terminal',
+            interruptAccepted: false,
+            interruptAttempt: null,
+        };
+        if (context.conversationId !== sessionId)
+            throw new SessionNotFoundError(sessionId);
+        return this.#subscribe(context, turnId, cleanCursor(afterSequence));
+    }
+    async activeTurn(sessionId) {
+        const record = this.#requireSession(sessionId);
+        if (!record.busyTurnId)
+            return null;
+        return this.#conversations.getTurn(record.scope, record.busyTurnId);
+    }
+    async latestTurn(sessionId) {
+        const record = this.#requireSession(sessionId);
+        return this.#conversations.getLatestTurn(record.scope, sessionId);
+    }
+    async replayTurn(sessionId, turnId, afterSequence = 0) {
+        const record = this.#requireSession(sessionId);
+        const turn = await this.#conversations.getTurn(record.scope, turnId);
+        if (!turn || turn.conversationId !== sessionId)
+            throw new SessionNotFoundError(sessionId);
+        const updates = await this.#conversations.listTurnUpdates(record.scope, turnId, cleanCursor(afterSequence));
+        return Object.freeze({ turn, updates });
+    }
+    interruptSession(sessionId) {
+        const record = this.#requireSession(sessionId);
+        const turnId = record.busyTurnId;
+        if (!turnId)
+            return Promise.resolve(Object.freeze({ interrupted: false, turnId: null }));
+        const context = this.#turns.get(turnId);
+        if (!context || context.phase !== 'running') {
+            return Promise.resolve(Object.freeze({ interrupted: false, turnId: null }));
+        }
+        if (context.interruptAttempt)
+            return context.interruptAttempt;
+        if (!this.#runtime.interruptTurn)
+            throw new InterruptUnsupportedError(sessionId);
+        const attempt = Promise.resolve(this.#runtime.interruptTurn({
+            sessionId,
+            turnId,
+            session: record.runtimeSession,
+            execution: context.execution,
+        })).then(() => {
+            context.interruptAccepted = true;
+            return Object.freeze({ interrupted: true, turnId });
+        }).catch((error) => {
+            context.interruptAttempt = null;
+            throw error;
+        });
+        context.interruptAttempt = attempt;
+        return attempt;
+    }
+    async inspectSession(sessionId) {
+        const record = this.#requireSession(sessionId);
+        const conversation = await this.#conversations.getConversation(record.scope, sessionId);
+        if (!conversation)
+            throw new SessionNotFoundError(sessionId);
+        return conversation;
+    }
+    listConversations(options = {}) {
+        return this.#conversations.listConversations(this.#ownerUserId, options);
+    }
+    listMessages(sessionId) {
+        const record = this.#requireSession(sessionId);
+        return this.#conversations.listMessages(record.scope, sessionId);
+    }
+    updateTitle(sessionId, title) {
+        const record = this.#requireSession(sessionId);
+        return this.#conversations.updateTitle(record.scope, sessionId, cleanTitle(title), this.#clockIso());
+    }
+    markSeen(sessionId) {
+        const record = this.#requireSession(sessionId);
+        return this.#conversations.markSeen(record.scope, sessionId, this.#clockIso());
+    }
+    async archiveSession(sessionId) {
+        const record = this.#requireSession(sessionId);
+        if (record.busyTurnId)
+            throw new SessionBusyError(sessionId);
+        return this.#conversations.archiveConversation(record.scope, sessionId, this.#clockIso());
+    }
+    recoverInterruptedTurns() {
+        return this.#conversations.recoverInterrupted(this.#ownerUserId, this.#clockIso());
+    }
+    async closeSession(sessionId) {
+        const record = this.#requireSession(sessionId);
+        if (record.busyTurnId)
+            throw new SessionBusyError(sessionId);
+        await this.#runtime.closeSession?.(sessionId, record.runtimeSession);
+        this.#sessions.delete(sessionId);
+    }
+    async close() {
+        for (const record of this.#sessions.values()) {
+            if (record.busyTurnId)
+                throw new SessionBusyError(record.id);
+        }
+        for (const record of this.#sessions.values()) {
+            await this.#runtime.closeSession?.(record.id, record.runtimeSession);
+        }
+        this.#sessions.clear();
+        await this.#conversations.close?.();
+    }
+    async #pumpTurn(record, turnId, assistantMessageId, prompt, execution) {
+        const transcript = createAcpTranscriptState();
+        let status = 'completed';
+        let failure = null;
+        let providerCheckpoint = null;
+        let promptFailure = null;
+        try {
+            const source = await this.#runtime.prompt({
+                sessionId: record.id,
+                turnId,
+                session: record.runtimeSession,
+                prompt,
+                execution,
+                previousExecution: record.execution,
+            });
+            record.execution = execution;
+            for await (const updates of this.#batches(source)) {
+                const storedUpdates = await this.#conversations.appendTurnUpdates({
+                    ...record.scope,
+                    conversationId: record.id,
+                    turnId,
+                    updates,
+                });
+                for (const stored of storedUpdates) {
+                    applyAcpTranscriptUpdate(transcript, stored.update);
+                    this.#announceUpdate(turnId, stored);
+                }
+            }
+            try {
+                providerCheckpoint = jsonCheckpoint(await this.#runtime.checkpointSession?.({
+                    sessionId: record.id,
+                    session: record.runtimeSession,
+                    execution,
+                }));
+            }
+            catch {
+                // A completed provider turn remains complete when optional native
+                // continuation capture fails. Canonical messages remain resumable.
+                providerCheckpoint = null;
+            }
+        }
+        catch (error) {
+            promptFailure = error;
+        }
+        const context = this.#turns.get(turnId);
+        if (context) {
+            context.phase = 'sealing';
+            if (context.interruptAttempt) {
+                try {
+                    await context.interruptAttempt;
+                }
+                catch { /* the prompt result decides below */ }
+            }
+        }
+        if (context?.interruptAccepted) {
+            status = 'cancelled';
+        }
+        else if (promptFailure !== null) {
+            status = 'failed';
+            failure = errorRecord(promptFailure);
+        }
+        try {
+            const turn = await this.#conversations.sealTurn({
+                ...record.scope,
+                conversationId: record.id,
+                turnId,
+                assistantMessageId,
+                status,
+                assistantParts: finalizeAcpTranscript(transcript, status === 'failed'),
+                modelId: execution.contract.model.modelId,
+                error: failure,
+                providerCheckpoint: providerCheckpoint === null ? null : {
+                    conversationId: record.id,
+                    executionRevision: execution.revision,
+                    adapterId: execution.contract.agent.adapterId,
+                    checkpoint: providerCheckpoint,
+                    updatedAt: this.#clockIso(),
+                },
+                completedAt: this.#clockIso(),
+            });
+            this.#announceTerminal(turnId, turn);
+            if (status === 'failed')
+                throw new TurnStreamError(turn);
+            return turn;
+        }
+        catch (error) {
+            if (error instanceof TurnStreamError)
+                throw error;
+            const persistenceError = error instanceof Error ? error : new Error(String(error));
+            this.#failSubscribers(turnId, persistenceError);
+            throw persistenceError;
+        }
+        finally {
+            if (context)
+                context.phase = 'terminal';
+            if (record.busyTurnId === turnId)
+                record.busyTurnId = null;
+        }
+    }
+    async *#batches(source) {
+        const iterator = source[Symbol.asyncIterator]();
+        let next = await iterator.next();
+        while (!next.done) {
+            const batch = [{ update: next.value, createdAt: this.#clockIso() }];
+            const policy = this.#journalBatch;
+            if (!policy || !this.#isContentDelta(next.value)) {
+                yield batch;
+                next = await iterator.next();
+                continue;
+            }
+            const maximum = Number.isFinite(policy.maxUpdates)
+                ? Math.max(1, Math.floor(policy.maxUpdates))
+                : 1;
+            const delay = Number.isFinite(policy.maxDelayMs)
+                ? Math.max(0, Math.floor(policy.maxDelayMs))
+                : 0;
+            let pending = iterator.next();
+            let held = null;
+            while (batch.length < maximum) {
+                const race = await Promise.race([
+                    pending.then((result) => ({ kind: 'next', result })),
+                    policy.wait(delay).then(() => ({ kind: 'timeout' })),
+                ]);
+                if (race.kind === 'timeout')
+                    break;
+                if (race.result.done) {
+                    held = race.result;
+                    break;
+                }
+                if (!this.#isContentDelta(race.result.value)) {
+                    held = race.result;
+                    break;
+                }
+                batch.push({ update: race.result.value, createdAt: this.#clockIso() });
+                pending = iterator.next();
+            }
+            yield batch;
+            next = held || await pending;
+        }
+    }
+    #isContentDelta(update) {
+        const kind = update['sessionUpdate'];
+        return kind === 'agent_message_chunk' || kind === 'agent_thought_chunk';
+    }
+    async *#subscribe(context, turnId, afterSequence) {
+        const buffer = new LiveTurnBuffer(turnId, this.#subscriberBufferSize);
+        const subscribers = this.#subscribers.get(turnId) || new Set();
+        subscribers.add(buffer);
+        this.#subscribers.set(turnId, subscribers);
+        let cursor = afterSequence;
+        try {
+            while (true) {
+                const backlog = await this.#conversations.listTurnUpdates(context.scope, turnId, cursor);
+                for (const stored of backlog)
+                    buffer.offer(stored, cursor);
+                let next = buffer.takeAfter(cursor);
+                while (next) {
+                    cursor = next.sequence;
+                    yield durableUpdate(next.update, next);
+                    next = buffer.takeAfter(cursor);
+                }
+                if (buffer.failure)
+                    throw buffer.failure;
+                const terminal = buffer.terminal || await this.#conversations.getTurn(context.scope, turnId);
+                if (terminal && terminal.status !== 'running') {
+                    if (terminal.status === 'failed' || terminal.status === 'interrupted')
+                        throw new TurnStreamError(terminal);
+                    return;
+                }
+                await buffer.wait();
+            }
+        }
+        finally {
+            subscribers.delete(buffer);
+            if (subscribers.size === 0)
+                this.#subscribers.delete(turnId);
+        }
+    }
+    #announceUpdate(turnId, update) {
+        for (const subscriber of this.#subscribers.get(turnId) || [])
+            subscriber.offer(update, 0);
+    }
+    #announceTerminal(turnId, turn) {
+        for (const subscriber of this.#subscribers.get(turnId) || [])
+            subscriber.finish(turn);
+    }
+    #failSubscribers(turnId, error) {
+        for (const subscriber of this.#subscribers.get(turnId) || [])
+            subscriber.fail(error);
+    }
+    #scope(execution) {
+        return Object.freeze({
+            ownerUserId: this.#ownerUserId,
+            agentInstallationId: execution.contract.agent.installationId,
+        });
+    }
+    #assertInstallation(scope, execution, sessionId) {
+        if (scope.agentInstallationId !== execution.contract.agent.installationId) {
+            throw new SessionAgentMismatchError(sessionId);
+        }
+    }
+    #requireSession(sessionId) {
+        const record = this.#sessions.get(sessionId);
+        if (!record)
+            throw new SessionNotFoundError(sessionId);
+        return record;
+    }
+}
+//# sourceMappingURL=chat.js.map