@rimori/client 2.5.14-next.2 → 2.5.14-next.4

package/dist/index.d.ts

@@ -17,3 +17,4 @@ export type { TriggerAction } from './plugin/module/ExerciseModule';
 export type { MacroAccomplishmentPayload, MicroAccomplishmentPayload } from './controller/AccomplishmentController';
 export type { EventBusMessage } from './fromRimori/EventBus';
 export type { Theme, ApplicationMode } from './plugin/module/PluginModule';
+export * from './plugin/TTS/MessageSender';

package/dist/index.js

@@ -9,3 +9,4 @@ export * from './plugin/StandaloneClient';
 export { setupWorker } from './worker/WorkerSetup';
 export { AudioController } from './controller/AudioController';
 export { Translator } from './controller/TranslationController';
+export * from './plugin/TTS/MessageSender';

package/dist/modules.d.ts

@@ -2,3 +2,4 @@ export * from './plugin/module/AIModule';
 export * from './fromRimori/PluginTypes';
 export * from './fromRimori/EventBus';
 export * from './cli/types/DatabaseTypes';
+export * from './plugin/TTS/MessageSender';

package/dist/modules.js

@@ -3,3 +3,4 @@ export * from './plugin/module/AIModule';
 export * from './fromRimori/PluginTypes';
 export * from './fromRimori/EventBus';
 export * from './cli/types/DatabaseTypes';
+export * from './plugin/TTS/MessageSender';

package/dist/plugin/RimoriClient.js

@@ -15,6 +15,7 @@ import { DbModule } from './module/DbModule';
 import { EventModule } from './module/EventModule';
 import { AIModule } from './module/AIModule';
 import { ExerciseModule } from './module/ExerciseModule';
+import { EventBus } from '../fromRimori/EventBus';
 export class RimoriClient {
     constructor(controller, supabase, info) {
         this.navigation = {
@@ -30,7 +31,10 @@ export class RimoriClient {
         this.rimoriInfo = info;
         this.sharedContent = new SharedContentController(supabase, this);
         this.ai = new AIModule(info.backendUrl, () => this.rimoriInfo.token);
-        this.event = new EventModule(info.pluginId);
+        this.ai.setOnRateLimited((exercisesRemaining) => {
+            EventBus.emit(info.pluginId, 'global.quota.triggerExceeded', { exercises_remaining: exercisesRemaining });
+        });
+        this.event = new EventModule(info.pluginId, info.backendUrl, () => this.rimoriInfo.token, this.ai);
         this.db = new DbModule(supabase, controller, info);
         this.plugin = new PluginModule(supabase, controller, info, this.ai);
         this.exercise = new ExerciseModule(supabase, controller, info, this.event);

package/dist/plugin/TTS/ChunkedAudioPlayer.d.ts

@@ -0,0 +1,29 @@
+export declare class ChunkedAudioPlayer {
+    private audioContext;
+    private chunkQueue;
+    private isPlaying;
+    private analyser;
+    private dataArray;
+    private shouldMonitorLoudness;
+    private isMonitoring;
+    private handle;
+    private volume;
+    private loudnessCallback;
+    private currentIndex;
+    private startedPlaying;
+    private onEndOfSpeech;
+    private readonly backgroundNoiseLevel;
+    constructor();
+    private init;
+    setOnLoudnessChange(callback: (value: number) => void): void;
+    setVolume(volume: number): void;
+    addChunk(chunk: ArrayBuffer, position: number): Promise<void>;
+    private playChunks;
+    stopPlayback(): void;
+    cleanup(): void;
+    private playChunk;
+    playAgain(): Promise<void>;
+    private monitorLoudness;
+    reset(): void;
+    setOnEndOfSpeech(callback: () => void): void;
+}

package/dist/plugin/TTS/ChunkedAudioPlayer.js

@@ -0,0 +1,205 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+export class ChunkedAudioPlayer {
+    constructor() {
+        this.chunkQueue = [];
+        this.isPlaying = false;
+        this.shouldMonitorLoudness = true;
+        this.isMonitoring = false;
+        this.handle = 0;
+        this.volume = 1.0;
+        this.loudnessCallback = () => { };
+        this.currentIndex = 0;
+        this.startedPlaying = false;
+        this.onEndOfSpeech = () => { };
+        this.backgroundNoiseLevel = 30; // Background noise level that should be treated as baseline (0)
+        this.init();
+    }
+    init() {
+        this.audioContext = new AudioContext();
+        this.analyser = this.audioContext.createAnalyser();
+        this.analyser.fftSize = 256; // Set the FFT size (smaller values provide faster updates, larger ones give better resolution)
+        const bufferLength = this.analyser.frequencyBinCount;
+        this.dataArray = new Uint8Array(bufferLength); // Array to hold frequency data
+    }
+    setOnLoudnessChange(callback) {
+        this.loudnessCallback = callback;
+    }
+    setVolume(volume) {
+        this.volume = volume;
+    }
+    addChunk(chunk, position) {
+        return __awaiter(this, void 0, void 0, function* () {
+            console.log('Adding chunk', position, chunk);
+            this.chunkQueue[position] = chunk;
+            // console.log("received chunk", {
+            //     chunkQueue: this.chunkQueue.length,
+            //     isPlaying: this.isPlaying,
+            // })
+            if (position === 0 && !this.startedPlaying) {
+                this.startedPlaying = true;
+                this.playChunks();
+            }
+        });
+    }
+    playChunks() {
+        // console.log({ isPlaying: this.isPlaying });
+        if (this.isPlaying)
+            return;
+        if (!this.chunkQueue[this.currentIndex]) {
+            // wait until the correct chunk arrives
+            setTimeout(() => this.playChunks(), 10);
+        }
+        this.isPlaying = true;
+        this.playChunk(this.chunkQueue[this.currentIndex]).then(() => {
+            this.isPlaying = false;
+            this.currentIndex++;
+            if (this.chunkQueue[this.currentIndex]) {
+                this.shouldMonitorLoudness = true;
+                this.playChunks();
+            }
+            else {
+                // console.log('Playback finished', { currentIndex: this.currentIndex, chunkQueue: this.chunkQueue });
+                setTimeout(() => {
+                    // console.log('Check again if really playback finished', { currentIndex: this.currentIndex, chunkQueue: this.chunkQueue });
+                    if (this.chunkQueue.length > this.currentIndex) {
+                        this.playChunks();
+                    }
+                    else {
+                        this.startedPlaying = false;
+                        this.shouldMonitorLoudness = false;
+                    }
+                }, 1000);
+            }
+        });
+    }
+    stopPlayback() {
+        // console.log('Stopping playback');
+        // Implement logic to stop the current playback
+        this.isPlaying = false;
+        this.chunkQueue = [];
+        this.startedPlaying = false;
+        this.shouldMonitorLoudness = false;
+        cancelAnimationFrame(this.handle);
+    }
+    cleanup() {
+        // Stop playback first
+        this.stopPlayback();
+        // Close AudioContext to free resources
+        if (this.audioContext && this.audioContext.state !== 'closed') {
+            this.audioContext.close().catch((e) => {
+                console.warn('Error closing AudioContext:', e);
+            });
+        }
+    }
+    playChunk(chunk) {
+        // console.log({queue: this.chunkQueue})
+        if (!chunk) {
+            return Promise.resolve();
+        }
+        // console.log('Playing chunk', chunk);
+        return new Promise((resolve) => {
+            const source = this.audioContext.createBufferSource();
+            this.audioContext.decodeAudioData(chunk.slice(0)).then((audioBuffer) => {
+                source.buffer = audioBuffer;
+                // Create a GainNode for volume control
+                const gainNode = this.audioContext.createGain();
+                gainNode.gain.value = this.volume;
+                // Connect the source to the GainNode, then to the analyser node, then to the destination (speakers)
+                source.connect(gainNode);
+                gainNode.connect(this.analyser);
+                this.analyser.connect(this.audioContext.destination);
+                source.start(0);
+                // console.log('Playing chunk', this.currentIndex);
+                gainNode.gain.value = this.volume;
+                source.onended = () => {
+                    // console.log('Chunk ended');
+                    resolve();
+                };
+                // Start monitoring loudness only once
+                if (!this.isMonitoring) {
+                    this.isMonitoring = true;
+                    this.shouldMonitorLoudness = true;
+                    this.monitorLoudness();
+                }
+            });
+        });
+    }
+    playAgain() {
+        return __awaiter(this, void 0, void 0, function* () {
+            console.log('Playing again');
+            if (this.chunkQueue.length > 0 && !this.isPlaying) {
+                this.playChunks();
+            }
+        });
+    }
+    monitorLoudness() {
+        // Stop monitoring when the flag is false
+        if (!this.shouldMonitorLoudness) {
+            // console.log('Loudness monitoring stopped.');
+            cancelAnimationFrame(this.handle);
+            this.loudnessCallback(0);
+            this.onEndOfSpeech();
+            return;
+        }
+        // Get the time domain data from the analyser (this is a snapshot of the waveform)
+        this.analyser.getByteTimeDomainData(this.dataArray);
+        // Calculate the RMS (root mean square) of the waveform values to get the perceived loudness
+        let sum = 0;
+        for (let i = 0; i < this.dataArray.length; i++) {
+            const value = this.dataArray[i] / 128.0 - 1.0; // Normalize between -1 and 1
+            sum += value * value;
+        }
+        const rms = Math.sqrt(sum / this.dataArray.length);
+        // Handle the case where RMS is 0 to avoid log10(0)
+        if (rms === 0) {
+            // console.log('Current loudness: Silent');
+        }
+        else {
+            let loudnessInDb = 20 * Math.log10(rms); // Convert to dB
+            // console.log('Current loudness:' + loudnessInDb);
+            const minDb = -57;
+            const maxDb = -15;
+            if (loudnessInDb < minDb) {
+                loudnessInDb = minDb;
+            }
+            if (loudnessInDb > maxDb) {
+                loudnessInDb = maxDb;
+            }
+            let loudnessScale = ((loudnessInDb - minDb) / (maxDb - minDb)) * 100;
+            // Adjust loudness: shift zero level up by background noise amount
+            // Values below background noise level are set to 0
+            // Values above are remapped to 0-100 scale
+            if (loudnessScale < this.backgroundNoiseLevel) {
+                loudnessScale = 0;
+            }
+            else {
+                // Remap from [backgroundNoiseLevel, 100] to [0, 100]
+                loudnessScale = ((loudnessScale - this.backgroundNoiseLevel) / (100 - this.backgroundNoiseLevel)) * 100;
+            }
+            this.loudnessCallback(Math.round(loudnessScale));
+        }
+        // Call this method again at regular intervals if you want continuous loudness monitoring
+        this.handle = requestAnimationFrame(() => this.monitorLoudness());
+    }
+    reset() {
+        // console.log('Resetting player');
+        this.stopPlayback();
+        this.currentIndex = 0;
+        this.shouldMonitorLoudness = true;
+        //reset to the beginning when the class gets initialized
+        this.isMonitoring = false;
+        this.isPlaying = false;
+        this.init();
+    }
+    setOnEndOfSpeech(callback) {
+        this.onEndOfSpeech = callback;
+    }
+}

package/dist/plugin/TTS/MessageSender.d.ts

@@ -0,0 +1,21 @@
+type VoiceBackend = (text: string, voice?: string, speed?: number, language?: string, cache?: boolean) => Promise<Blob>;
+export declare class MessageSender {
+    private player;
+    private fetchedSentences;
+    private lastLoading;
+    private voice;
+    private voiceBackend;
+    private cache;
+    constructor(voiceBackend: VoiceBackend, voice: string, cache?: boolean);
+    private getCompletedSentences;
+    handleNewText(currentText: string | undefined, isLoading: boolean): Promise<void>;
+    private generateSpeech;
+    play(): void;
+    stop(): void;
+    cleanup(): void;
+    private reset;
+    setVolume(volume: number): void;
+    setOnLoudnessChange(callback: (value: number) => void): void;
+    setOnEndOfSpeech(callback: () => void): void;
+}
+export {};

package/dist/plugin/TTS/MessageSender.js

@@ -0,0 +1,95 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { ChunkedAudioPlayer } from './ChunkedAudioPlayer';
+export class MessageSender {
+    constructor(voiceBackend, voice, cache = false) {
+        this.player = new ChunkedAudioPlayer();
+        this.fetchedSentences = new Set();
+        this.lastLoading = false;
+        if ((voice === null || voice === void 0 ? void 0 : voice.split('_').length) !== 2) {
+            throw new Error("Invalid voice id format '" + voice + "'. Voice id needs to look like <provider>_<voice_id>");
+        }
+        this.voiceBackend = voiceBackend;
+        this.voice = voice;
+        this.cache = cache;
+    }
+    getCompletedSentences(currentText, isLoading) {
+        // Split the text based on the following characters: .?!
+        // Only split on : when followed by a space
+        const pattern = /(.+?[.?!]|.+?:\s+|.+?\n+)/g;
+        const result = [];
+        let match;
+        while ((match = pattern.exec(currentText)) !== null) {
+            const sentence = match[0].trim();
+            if (sentence.length > 0) {
+                result.push(sentence);
+            }
+        }
+        if (!isLoading) {
+            const lastFullSentence = result[result.length - 1];
+            const leftoverIndex = currentText.lastIndexOf(lastFullSentence) + lastFullSentence.length;
+            if (leftoverIndex < currentText.length) {
+                result.push(currentText.slice(leftoverIndex).trim());
+            }
+        }
+        return result;
+    }
+    handleNewText(currentText, isLoading) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.lastLoading && isLoading) {
+                this.reset();
+            }
+            this.lastLoading = isLoading;
+            if (!currentText) {
+                return;
+            }
+            const sentences = this.getCompletedSentences(currentText, isLoading);
+            for (let i = 0; i < sentences.length; i++) {
+                const sentence = sentences[i];
+                if (!this.fetchedSentences.has(sentence)) {
+                    this.fetchedSentences.add(sentence);
+                    const audioData = yield this.generateSpeech(sentence);
+                    yield this.player.addChunk(audioData, i);
+                }
+            }
+        });
+    }
+    generateSpeech(sentence) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const blob = yield this.voiceBackend(sentence, this.voice, 1.0, undefined, this.cache);
+            return yield blob.arrayBuffer();
+        });
+    }
+    play() {
+        this.player.playAgain();
+    }
+    stop() {
+        this.player.stopPlayback();
+    }
+    cleanup() {
+        this.player.cleanup();
+    }
+    reset() {
+        this.stop();
+        this.fetchedSentences.clear();
+        this.player.reset();
+    }
+    setVolume(volume) {
+        this.player.setVolume(volume);
+    }
+    setOnLoudnessChange(callback) {
+        this.player.setOnLoudnessChange((loudness) => {
+            callback(loudness);
+        });
+    }
+    setOnEndOfSpeech(callback) {
+        this.player.setOnEndOfSpeech(callback);
+    }
+}

package/dist/plugin/module/AIModule.d.ts

@@ -58,7 +58,17 @@ export interface ObjectRequest {
 export declare class AIModule {
     private getToken;
     private backendUrl;
+    private sessionTokenId;
+    private onRateLimitedCb?;
     constructor(backendUrl: string, getToken: () => string);
+    /** Returns the current exercise session token ID (null if no active session). */
+    getSessionTokenId(): string | null;
+    /** Sets the session token ID (used by workers inheriting a session from the plugin). */
+    setSessionToken(id: string): void;
+    /** Clears the stored session token (called after macro accomplishment). */
+    clearSessionToken(): void;
+    /** Registers a callback invoked whenever a 429 rate-limit response is received. */
+    setOnRateLimited(cb: (exercisesRemaining: number) => void): void;
     /**
      * Generate text from messages using AI.
      * @param messages The messages to generate text from.

package/dist/plugin/module/AIModule.js

@@ -13,9 +13,26 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
  */
 export class AIModule {
     constructor(backendUrl, getToken) {
+        this.sessionTokenId = null;
         this.backendUrl = backendUrl;
         this.getToken = getToken;
     }
+    /** Returns the current exercise session token ID (null if no active session). */
+    getSessionTokenId() {
+        return this.sessionTokenId;
+    }
+    /** Sets the session token ID (used by workers inheriting a session from the plugin). */
+    setSessionToken(id) {
+        this.sessionTokenId = id;
+    }
+    /** Clears the stored session token (called after macro accomplishment). */
+    clearSessionToken() {
+        this.sessionTokenId = null;
+    }
+    /** Registers a callback invoked whenever a 429 rate-limit response is received. */
+    setOnRateLimited(cb) {
+        this.onRateLimitedCb = cb;
+    }
     /**
      * Generate text from messages using AI.
      * @param messages The messages to generate text from.
@@ -78,13 +95,14 @@ export class AIModule {
      */
     getVoice(text_1) {
         return __awaiter(this, arguments, void 0, function* (text, voice = 'alloy', speed = 1, language, cache = false) {
+            var _a;
             return yield fetch(`${this.backendUrl}/voice/tts`, {
                 method: 'POST',
                 headers: {
                     'Content-Type': 'application/json',
                     Authorization: `Bearer ${this.getToken()}`,
                 },
-                body: JSON.stringify({ input: text, voice, speed, language, cache }),
+                body: JSON.stringify({ input: text, voice, speed, language, cache, session_token_id: (_a = this.sessionTokenId) !== null && _a !== void 0 ? _a : undefined }),
             }).then((r) => r.blob());
         });
     }
@@ -101,6 +119,9 @@ export class AIModule {
             if (language) {
                 formData.append('language', language.code);
             }
+            if (this.sessionTokenId) {
+                formData.append('session_token_id', this.sessionTokenId);
+            }
             return yield fetch(`${this.backendUrl}/voice/stt`, {
                 method: 'POST',
                 headers: { Authorization: `Bearer ${this.getToken()}` },
@@ -172,6 +193,7 @@ export class AIModule {
     }
     streamObject(params) {
         return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d;
             const { messages, responseSchema, onResult = () => null, cache = false, tools = [], model = undefined, knowledgeId, } = params;
             const chatMessages = messages.map((message, index) => (Object.assign(Object.assign({}, message), { id: `${index + 1}` })));
             const response = yield fetch(`${this.backendUrl}/ai/llm`, {
@@ -183,11 +205,18 @@ export class AIModule {
                     messages: chatMessages,
                     model,
                     knowledge_id: knowledgeId,
+                    session_token_id: (_a = this.sessionTokenId) !== null && _a !== void 0 ? _a : undefined,
                 }),
                 method: 'POST',
                 headers: { Authorization: `Bearer ${this.getToken()}`, 'Content-Type': 'application/json' },
             });
             if (!response.ok) {
+                if (response.status === 429) {
+                    const body = yield response.json().catch(() => ({}));
+                    const remaining = (_b = body.exercises_remaining) !== null && _b !== void 0 ? _b : 0;
+                    (_c = this.onRateLimitedCb) === null || _c === void 0 ? void 0 : _c.call(this, remaining);
+                    throw new Error(`Rate limit exceeded: ${(_d = body.error) !== null && _d !== void 0 ? _d : 'Daily exercise limit reached'}. exercises_remaining: ${remaining}`);
+                }
                 throw new Error(`Failed to stream object: ${response.status} ${response.statusText}`);
             }
             if (!response.body) {
@@ -212,6 +241,19 @@ export class AIModule {
                 const chunk = decoder.decode(value, { stream: true });
                 const lines = chunk.split('\n').filter((line) => line.trim());
                 for (const line of lines) {
+                    // Handle token: line (session token issued by backend on first AI call)
+                    if (line.startsWith('token:')) {
+                        try {
+                            const tokenData = JSON.parse(line.slice(6).trim());
+                            if (tokenData.token_id) {
+                                this.sessionTokenId = tokenData.token_id;
+                            }
+                        }
+                        catch (_e) {
+                            console.error('Failed to parse token: line', line);
+                        }
+                        continue;
+                    }
                     const command = line.substring(0, 5);
                     const dataStr = line.substring(5).trim();
                     if (dataStr === '[DONE]') {

package/dist/plugin/module/EventModule.d.ts

@@ -1,6 +1,7 @@
 import { MainPanelAction, SidebarAction } from '../../fromRimori/PluginTypes';
 import { AccomplishmentPayload } from '../../controller/AccomplishmentController';
 import { EventBusMessage, EventHandler, EventPayload, EventListener } from '../../fromRimori/EventBus';
+import { AIModule } from './AIModule';
 /**
  * Event module for plugin event bus operations.
  * Provides methods for emitting, listening to, and responding to events.
@@ -8,7 +9,10 @@ import { EventBusMessage, EventHandler, EventPayload, EventListener } from '../.
 export declare class EventModule {
     private pluginId;
     private accomplishmentController;
-    constructor(pluginId: string);
+    private aiModule;
+    private backendUrl;
+    private getToken;
+    constructor(pluginId: string, backendUrl: string, getToken: () => string, aiModule: AIModule);
     getGlobalEventTopic(preliminaryTopic: string): string;
     /**
      * Emit an event to Rimori or a plugin.
@@ -51,7 +55,7 @@ export declare class EventModule {
      * Emit an accomplishment.
      * @param payload The payload to emit.
      */
-    emitAccomplishment(payload: AccomplishmentPayload): void;
+    emitAccomplishment(payload: AccomplishmentPayload): Promise<void>;
     /**
      * Subscribe to an accomplishment.
      * @param accomplishmentTopic The topic to subscribe to.

package/dist/plugin/module/EventModule.js

@@ -1,3 +1,12 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 import { AccomplishmentController } from '../../controller/AccomplishmentController';
 import { EventBus } from '../../fromRimori/EventBus';
 /**
@@ -5,8 +14,11 @@ import { EventBus } from '../../fromRimori/EventBus';
  * Provides methods for emitting, listening to, and responding to events.
  */
 export class EventModule {
-    constructor(pluginId) {
+    constructor(pluginId, backendUrl, getToken, aiModule) {
         this.pluginId = pluginId;
+        this.backendUrl = backendUrl;
+        this.getToken = getToken;
+        this.aiModule = aiModule;
         this.accomplishmentController = new AccomplishmentController(pluginId);
     }
     getGlobalEventTopic(preliminaryTopic) {
@@ -86,7 +98,24 @@ export class EventModule {
      * @param payload The payload to emit.
      */
     emitAccomplishment(payload) {
-        this.accomplishmentController.emitAccomplishment(payload);
+        return __awaiter(this, void 0, void 0, function* () {
+            if (payload.type === 'macro') {
+                const sessionId = this.aiModule.getSessionTokenId();
+                if (sessionId) {
+                    try {
+                        yield fetch(`${this.backendUrl}/ai/session/${sessionId}/complete`, {
+                            method: 'PATCH',
+                            headers: { Authorization: `Bearer ${this.getToken()}` },
+                        });
+                    }
+                    catch (_a) {
+                        // non-fatal — session will expire naturally
+                    }
+                    this.aiModule.clearSessionToken();
+                }
+            }
+            this.accomplishmentController.emitAccomplishment(payload);
+        });
     }
     /**
      * Subscribe to an accomplishment.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rimori/client",
-  "version": "2.5.14-next.2",
+  "version": "2.5.14-next.4",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "repository": {