@rimori/client 1.1.10 → 1.3.0

package/dist/plugin/RimoriClient.js

@@ -7,16 +7,15 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { generateText, streamChatGPT } from "../controller/AIController";
-import { generateObject as generateObjectFunction } from "../controller/ObjectController";
-import { SettingsController } from "../controller/SettingsController";
-import { SharedContentController } from "../controller/SharedContentController";
-import { getPlugins } from "../controller/SidePluginController";
-import { getSTTResponse, getTTSResponse } from "../controller/VoiceController";
+import { generateText, streamChatGPT } from "../core/controller/AIController";
+import { generateObject } from "../core/controller/ObjectController";
+import { SettingsController } from "../core/controller/SettingsController";
+import { SharedContentController } from "../core/controller/SharedContentController";
+import { getSTTResponse, getTTSResponse } from "../core/controller/VoiceController";
+import { EventBus } from "../fromRimori/EventBus";
 import { AccomplishmentHandler } from "./AccomplishmentHandler";
-import { EventBus } from "./fromRimori/EventBus";
 export class RimoriClient {
-    constructor(options) {
+    constructor(supabase, info, pluginController) {
         this.event = {
             /**
              * Emit an event to Rimori or a plugin.
@@ -46,11 +45,11 @@ export class RimoriClient {
              * Subscribe to an event.
              * @param topic The topic to subscribe to.
              * @param callback The callback to call when the event is emitted.
-             * @returns The unsubscribe ids.
+             * @returns An EventListener object containing an off() method to unsubscribe the listeners.
              */
             on: (topic, callback) => {
                 const topics = Array.isArray(topic) ? topic : [topic];
-                return topics.map(topic => EventBus.on(this.pluginController.getGlobalEventTopic(topic), callback));
+                return EventBus.on(topics.map(t => this.pluginController.getGlobalEventTopic(t)), callback);
             },
             /**
              * Subscribe to an event once.
@@ -66,7 +65,8 @@ export class RimoriClient {
              * @param data The data to respond with.
              */
             respond: (topic, data) => {
-                EventBus.respond(this.plugin.pluginId, this.pluginController.getGlobalEventTopic(topic), data);
+                const topics = Array.isArray(topic) ? topic : [topic];
+                EventBus.respond(this.plugin.pluginId, topics.map(t => this.pluginController.getGlobalEventTopic(t)), data);
             },
             /**
              * Emit an accomplishment.
@@ -90,31 +90,48 @@ export class RimoriClient {
              * @param text Optional text to be used for the action like for example text that the translator would look up.
              */
             emitSidebarAction: (pluginId, actionKey, text) => {
-                this.event.emit("global.sidebar.triggerAction", { pluginId, actionKey, text });
+                this.event.emit("global.sidebar.triggerAction", { plugin_id: pluginId, action_key: actionKey, text });
+            },
+            onMainPanelAction: (callback) => {
+                // this needs to be a emit and on because the main panel action is triggered by the user and not by the plugin
+                this.event.emit("action.requestMain");
+                this.event.on("action.requestMain", ({ data }) => callback(data));
             }
         };
-        this.llm = {
+        this.navigation = {
+            toDashboard: () => {
+                this.event.emit("global.navigation.triggerToDashboard");
+            }
+        };
+        this.ai = {
             getText: (messages, tools) => __awaiter(this, void 0, void 0, function* () {
                 const token = yield this.pluginController.getToken();
-                return generateText(this.supabaseUrl, messages, tools || [], token).then(({ messages }) => messages[0].content[0].text);
+                return generateText(this.pluginController.getBackendUrl(), messages, tools || [], token).then(({ messages }) => messages[0].content[0].text);
             }),
             getSteamedText: (messages, onMessage, tools) => __awaiter(this, void 0, void 0, function* () {
                 const token = yield this.pluginController.getToken();
-                streamChatGPT(this.supabaseUrl, messages, tools || [], onMessage, token);
+                streamChatGPT(this.pluginController.getBackendUrl(), messages, tools || [], onMessage, token);
             }),
             getVoice: (text_1, ...args_1) => __awaiter(this, [text_1, ...args_1], void 0, function* (text, voice = "alloy", speed = 1, language) {
                 const token = yield this.pluginController.getToken();
-                return getTTSResponse(this.supabaseUrl, { input: text, voice, speed, language }, token);
+                return getTTSResponse(this.pluginController.getBackendUrl(), { input: text, voice, speed, language }, token);
+            }),
+            getTextFromVoice: (file) => __awaiter(this, void 0, void 0, function* () {
+                const token = yield this.pluginController.getToken();
+                return getSTTResponse(this.pluginController.getBackendUrl(), file, token);
             }),
-            getTextFromVoice: (file) => {
-                return getSTTResponse(this.superbase, file);
-            },
             getObject: (request) => __awaiter(this, void 0, void 0, function* () {
                 const token = yield this.pluginController.getToken();
-                return generateObjectFunction(this.supabaseUrl, request, token);
+                return generateObject(this.pluginController.getBackendUrl(), request, token);
             }),
             // getSteamedObject: this.generateObjectStream,
         };
+        this.runtime = {
+            fetchBackend: (url, options) => __awaiter(this, void 0, void 0, function* () {
+                const token = yield this.pluginController.getToken();
+                return fetch(this.pluginController.getBackendUrl() + url, Object.assign(Object.assign({}, options), { headers: Object.assign(Object.assign({}, options.headers), { 'Authorization': `Bearer ${token}` }) }));
+            })
+        };
         this.community = {
             /**
              * Shared content is a way to share completable content with other users using this plugin.
@@ -146,11 +163,15 @@ export class RimoriClient {
                  * @param contentType The type of shared content to fetch. E.g. assignments, exercises, etc.
                  * @param generatorInstructions The instructions for the creation of new shared content. The object will automatically be extended with a tool property with a topic and keywords property to let a new unique topic be generated.
                  * @param filter The optional additional filter for checking new shared content based on a column and value. This is useful if the aditional information stored on the shared content is used to further narrow down the kind of shared content wanted to be received. E.g. only adjective grammar exercises.
-                 * @param privateTopic An optional flag to indicate if the topic should be private and only be visible to the user. This is useful if the topic is not meant to be shared with other users. Like for personal topics or if the content is based on the personal study goal.
+                 * @param options An optional object with options for the new shared content.
+                 * @param options.privateTopic An optional flag to indicate if the topic should be private and only be visible to the user. This is useful if the topic is not meant to be shared with other users. Like for personal topics or if the content is based on the personal study goal.
+                 * @param options.skipDbSave An optional flag to indicate if the new shared content should not be saved to the database. This is useful if the new shared content is not meant to be saved to the database.
+                 * @param options.alwaysGenerateNew An optional flag to indicate if the new shared content should always be generated even if there is already a content with the same filter. This is useful if the new shared content is not meant to be saved to the database.
+                 * @param options.excludeIds An optional list of ids to exclude from the selection. This is useful if the new shared content is not meant to be saved to the database.
                  * @returns The new shared content.
                  */
-                getNew: (contentType, generatorInstructions, filter, privateTopic) => __awaiter(this, void 0, void 0, function* () {
-                    return yield this.sharedContentController.getNewSharedContent(contentType, generatorInstructions, filter, privateTopic);
+                getNew: (contentType, generatorInstructions, filter, options) => __awaiter(this, void 0, void 0, function* () {
+                    return yield this.sharedContentController.getNewSharedContent(contentType, generatorInstructions, filter, options);
                 }),
                 /**
                  * Create a new shared content item.
@@ -177,6 +198,14 @@ export class RimoriClient {
                 complete: (contentType, assignmentId) => __awaiter(this, void 0, void 0, function* () {
                     return yield this.sharedContentController.completeSharedContent(contentType, assignmentId);
                 }),
+                /**
+                 /**
+                  * Update the state of a shared content item for a specific user.
+                  * Useful for marking content as completed, ongoing, hidden, liked, disliked, or bookmarked.
+                  */
+                updateState: (params) => __awaiter(this, void 0, void 0, function* () {
+                    return yield this.sharedContentController.updateSharedContentState(params);
+                }),
                 /**
                  * Remove a shared content item.
                  * @param id The id of the shared content item to remove.
@@ -187,41 +216,53 @@ export class RimoriClient {
                 })
             }
         };
-        this.superbase = options.supabase;
-        this.pluginController = options.pluginController;
-        this.settingsController = new SettingsController(options.supabase, options.pluginId);
+        this.rimoriInfo = info;
+        this.superbase = supabase;
+        this.pluginController = pluginController;
+        this.settingsController = new SettingsController(supabase, info.pluginId);
         this.sharedContentController = new SharedContentController(this.superbase, this);
-        this.supabaseUrl = this.pluginController.getSupabaseUrl();
-        this.accomplishmentHandler = new AccomplishmentHandler(options.pluginId);
+        this.accomplishmentHandler = new AccomplishmentHandler(info.pluginId);
         this.from = this.from.bind(this);
         this.db = {
             from: this.from,
-            storage: this.superbase.storage,
+            // storage: this.superbase.storage,
             // functions: this.superbase.functions,
-            tablePrefix: options.tablePrefix,
+            tablePrefix: info.tablePrefix,
             getTableName: this.getTableName.bind(this),
         };
         this.plugin = {
-            pluginId: options.pluginId,
+            pluginId: info.pluginId,
             setSettings: (settings) => __awaiter(this, void 0, void 0, function* () {
                 yield this.settingsController.setSettings(settings);
             }),
             getSettings: (defaultSettings) => __awaiter(this, void 0, void 0, function* () {
                 return yield this.settingsController.getSettings(defaultSettings);
             }),
-            getInstalled: () => __awaiter(this, void 0, void 0, function* () {
-                return getPlugins(this.superbase);
-            }),
-            getUserInfo: () => __awaiter(this, void 0, void 0, function* () {
-                return this.settingsController.getUserInfo();
-            })
+            getUserInfo: () => {
+                return this.rimoriInfo.profile;
+            },
+            getPluginInfo: () => {
+                return {
+                    installedPlugins: this.rimoriInfo.installedPlugins,
+                    mainPanelPlugin: this.rimoriInfo.mainPanelPlugin,
+                    sidePanelPlugin: this.rimoriInfo.sidePanelPlugin,
+                };
+            }
         };
     }
+    /**
+     * Get a query parameter value that was passed via MessageChannel
+     * @param key The query parameter key
+     * @returns The query parameter value or null if not found
+     */
+    getQueryParam(key) {
+        return this.pluginController.getQueryParam(key);
+    }
     static getInstance(pluginController) {
         return __awaiter(this, void 0, void 0, function* () {
             if (!RimoriClient.instance) {
-                const { supabase, tablePrefix, pluginId } = yield pluginController.getClient();
-                RimoriClient.instance = new RimoriClient({ pluginController, supabase, tablePrefix, pluginId });
+                const client = yield pluginController.getClient();
+                RimoriClient.instance = new RimoriClient(client.supabase, client.info, pluginController);
             }
             return RimoriClient.instance;
         });
@@ -229,7 +270,13 @@ export class RimoriClient {
     from(relation) {
         return this.superbase.from(this.getTableName(relation));
     }
-    getTableName(type) {
-        return this.db.tablePrefix + "_" + type;
+    getTableName(table) {
+        if (/[A-Z]/.test(table)) {
+            throw new Error("Table name cannot include uppercase letters. Please use snake_case for table names.");
+        }
+        if (table.startsWith("global_")) {
+            return table.replace("global_", "");
+        }
+        return this.db.tablePrefix + "_" + table;
     }
 }

package/dist/plugin/StandaloneClient.d.ts

@@ -2,6 +2,7 @@ import { SupabaseClient } from "@supabase/supabase-js";
 export interface StandaloneConfig {
     url: string;
     key: string;
+    backendUrl?: string;
 }
 export declare class StandaloneClient {
     private static instance;

package/dist/plugin/StandaloneClient.js

@@ -7,8 +7,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { EventBus } from "./fromRimori/EventBus";
 import { createClient } from "@supabase/supabase-js";
+import { EventBus } from "../fromRimori/EventBus";
+import { DEFAULT_ANON_KEY, DEFAULT_ENDPOINT } from "../utils/endpoint";
 export class StandaloneClient {
     constructor(config) {
         this.supabase = createClient(config.url, config.key);
@@ -17,14 +18,14 @@ export class StandaloneClient {
     static getInstance() {
         return __awaiter(this, void 0, void 0, function* () {
             if (!StandaloneClient.instance) {
-                const config = yield fetch("http://localhost:3000/config.json").then(res => res.json()).catch(err => {
+                const config = yield fetch("https://app.rimori.se/config.json").then(res => res.json()).catch(err => {
                     console.warn("Error fetching config.json, using default values", err);
-                    return {
-                        SUPABASE_URL: "https://pheptqdoqsdnadgoihvr.supabase.co",
-                        SUPABASE_ANON_KEY: "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6InBoZXB0cWRvcXNkbmFkZ29paHZyIiwicm9sZSI6ImFub24iLCJpYXQiOjE3MzE2OTY2ODcsImV4cCI6MjA0NzI3MjY4N30.4GPFAXTF8685FaXISdAPNCIM-H3RGLo8GbyhQpu1mP0",
-                    };
                 });
-                StandaloneClient.instance = new StandaloneClient({ url: config.SUPABASE_URL, key: config.SUPABASE_ANON_KEY });
+                StandaloneClient.instance = new StandaloneClient({
+                    url: (config === null || config === void 0 ? void 0 : config.SUPABASE_URL) || DEFAULT_ENDPOINT,
+                    key: (config === null || config === void 0 ? void 0 : config.SUPABASE_ANON_KEY) || DEFAULT_ANON_KEY,
+                    backendUrl: (config === null || config === void 0 ? void 0 : config.BACKEND_URL) || 'https://api.rimori.se',
+                });
             }
             return StandaloneClient.instance;
         });
@@ -61,15 +62,28 @@ export class StandaloneClient {
                 var _a;
                 const session = yield supabase.auth.getSession();
                 console.log("session", session);
-                const { data, error } = yield supabase.functions.invoke("plugin-token", { headers: { authorization: `Bearer ${(_a = session.data.session) === null || _a === void 0 ? void 0 : _a.access_token}` } });
-                if (error) {
-                    throw new Error("Failed to get plugin token. " + error.message);
+                // Call the NestJS backend endpoint instead of the Supabase edge function
+                const response = yield fetch(`${config.backendUrl}/plugin/token`, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'Authorization': `Bearer ${(_a = session.data.session) === null || _a === void 0 ? void 0 : _a.access_token}`
+                    },
+                    body: JSON.stringify({
+                        pluginId: pluginId
+                    })
+                });
+                if (!response.ok) {
+                    const errorText = yield response.text();
+                    throw new Error(`Failed to get plugin token. ${response.status}: ${errorText}`);
                 }
+                const data = yield response.json();
                 return {
                     token: data.token,
                     pluginId: pluginId,
                     url: config.url,
                     key: config.key,
+                    backendUrl: config.backendUrl,
                     tablePrefix: pluginId,
                     expiration: new Date(Date.now() + 1000 * 60 * 60 * 1.5), // 1.5 hours
                 };

package/dist/plugin/ThemeSetter.d.ts

@@ -1 +1,2 @@
-export declare function setTheme(): void;
+export declare function setTheme(theme?: string | null): void;
+export declare function isDarkTheme(theme?: string | null): boolean;

package/dist/plugin/ThemeSetter.js

@@ -1,13 +1,19 @@
-export function setTheme() {
-    const urlParams = new URLSearchParams(window.location.search);
-    let theme = urlParams.get('theme');
-    if (!theme || theme === 'system') {
-        theme = window.matchMedia && window.matchMedia('(prefers-color-scheme: dark)').matches ? 'dark' : 'light';
-    }
+export function setTheme(theme) {
     document.documentElement.classList.add("dark:text-gray-200");
-    if (theme === 'dark') {
+    if (isDarkTheme(theme)) {
         document.documentElement.setAttribute("data-theme", "dark");
         document.documentElement.classList.add('dark', "dark:bg-gray-950");
         document.documentElement.style.background = "hsl(var(--background))";
     }
 }
+export function isDarkTheme(theme) {
+    // If no theme provided, try to get from URL as fallback (for standalone mode)
+    if (!theme) {
+        const urlParams = new URLSearchParams(window.location.search);
+        theme = urlParams.get('theme');
+    }
+    if (!theme || theme === 'system') {
+        return window.matchMedia && window.matchMedia('(prefers-color-scheme: dark)').matches;
+    }
+    return theme === 'dark';
+}

package/dist/providers/PluginProvider.d.ts

@@ -3,7 +3,10 @@ import { RimoriClient } from '../plugin/RimoriClient';
 interface PluginProviderProps {
     children: ReactNode;
     pluginId: string;
+    settings?: {
+        disableContextMenu?: boolean;
+    };
 }
 export declare const PluginProvider: React.FC<PluginProviderProps>;
-export declare const usePlugin: () => RimoriClient;
+export declare const useRimori: () => RimoriClient;
 export {};

package/dist/providers/PluginProvider.js

@@ -10,34 +10,47 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { createContext, useContext, useEffect, useState } from 'react';
 import { PluginController } from '../plugin/PluginController';
-import { EventBusHandler } from '../plugin/fromRimori/EventBus';
-import ContextMenu from '../core/components/ContextMenu';
+import { EventBusHandler } from '../fromRimori/EventBus';
+import ContextMenu from '../components/components/ContextMenu';
 import { StandaloneClient } from '../plugin/StandaloneClient';
 const PluginContext = createContext(null);
-export const PluginProvider = ({ children, pluginId }) => {
+export const PluginProvider = ({ children, pluginId, settings }) => {
     const [plugin, setPlugin] = useState(null);
     const [standaloneClient, setStandaloneClient] = useState(false);
+    const [applicationMode, setApplicationMode] = useState(null);
+    const [theme, setTheme] = useState(null);
+    const isSidebar = applicationMode === "sidebar";
+    const isSettings = applicationMode === "settings";
     useEffect(() => {
         initEventBus(pluginId);
-        const standaloneDetected = new URLSearchParams(window.location.search).get("secret") === null;
+        // Check if we're in an iframe context - if not, we're standalone
+        const standaloneDetected = window === window.parent;
         if (standaloneDetected && !standaloneClient) {
             StandaloneClient.getInstance().then(client => {
                 client.needsLogin().then((needLogin) => setStandaloneClient(needLogin ? client : true));
             });
         }
         if ((!standaloneDetected && !plugin) || (standaloneDetected && standaloneClient === true)) {
-            PluginController.getInstance(pluginId, standaloneDetected).then(setPlugin);
+            PluginController.getInstance(pluginId, standaloneDetected).then(client => {
+                setPlugin(client);
+                // Get applicationMode and theme from MessageChannel query params
+                if (!standaloneDetected) {
+                    const mode = client.getQueryParam("applicationMode");
+                    const themeParam = client.getQueryParam("rm_theme");
+                    setApplicationMode(mode);
+                    setTheme(themeParam);
+                }
+            });
         }
     }, [pluginId, standaloneClient]);
     //route change
     useEffect(() => {
         if (!plugin)
             return;
-        const url = new URL(window.location.href);
         //sidebar pages should not report url changes
-        if (url.searchParams.get("applicationMode") === "sidebar")
+        if (isSidebar)
             return;
-        let lastHash = url.hash;
+        let lastHash = window.location.hash;
         const emitUrlChange = (url) => plugin.event.emit('session.triggerUrlChange', { url });
         const interval = setInterval(() => {
             if (lastHash === window.location.hash)
@@ -66,18 +79,31 @@ export const PluginProvider = ({ children, pluginId }) => {
     if (!plugin) {
         return "";
     }
-    return (_jsxs(PluginContext.Provider, { value: plugin, children: [_jsx(ContextMenu, { client: plugin }), children] }));
+    return (_jsxs(PluginContext.Provider, { value: plugin, children: [!(settings === null || settings === void 0 ? void 0 : settings.disableContextMenu) && !isSidebar && !isSettings && _jsx(ContextMenu, { client: plugin }), children] }));
 };
-export const usePlugin = () => {
+export const useRimori = () => {
     const context = useContext(PluginContext);
     if (context === null) {
-        throw new Error('usePlugin must be used within an PluginProvider');
+        throw new Error('useRimori must be used within an PluginProvider');
     }
     return context;
 };
-function initEventBus(pluginId) {
+function getUrlParam(name) {
+    // First try to get from URL hash query params (for compatibility)
+    const hashParts = window.location.hash.split('?');
+    if (hashParts.length > 1) {
+        const hashParams = new URLSearchParams(hashParts[1]);
+        const hashValue = hashParams.get(name);
+        if (hashValue)
+            return hashValue;
+    }
+    // Fallback to regular URL search params
     const url = new URL(window.location.href);
-    const isSidebar = url.searchParams.get("applicationMode") === "sidebar";
+    return url.searchParams.get(name);
+}
+function initEventBus(pluginId) {
+    // For now, use URL fallback for EventBus naming - this will be updated once MessageChannel is ready
+    const isSidebar = getUrlParam("applicationMode") === "sidebar";
     EventBusHandler.getInstance("Plugin EventBus " + pluginId + " " + (isSidebar ? "sidebar" : "main"));
 }
 function StandaloneAuth({ onLogin }) {

package/dist/utils/Language.d.ts

@@ -61,6 +61,7 @@ export type Language = keyof typeof languageKeys;
 /**
  * Get the language name from the language code
  * @param languageCode The code of the language
+ * @param capitalize Whether to capitalize the first letter of the language name
  * @returns The language name
  */
-export declare function getLanguageName(languageCode: Language): string;
+export declare function getLanguageName(languageCode: Language, capitalize?: boolean): string;

package/dist/utils/Language.js

@@ -60,8 +60,10 @@ export const languageKeys = {
 /**
  * Get the language name from the language code
  * @param languageCode The code of the language
+ * @param capitalize Whether to capitalize the first letter of the language name
  * @returns The language name
  */
-export function getLanguageName(languageCode) {
-    return languageKeys[languageCode];
+export function getLanguageName(languageCode, capitalize = false) {
+    const lang = languageKeys[languageCode];
+    return capitalize ? lang.charAt(0).toUpperCase() + lang.slice(1) : lang;
 }

package/dist/utils/audioFormats.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Maps audio MIME types to their corresponding file extensions
+ * OpenAI supports: mp3, mp4, mpeg, mpga, m4a, wav, webm
+ */
+export declare const AUDIO_MIME_TO_EXTENSION: Record<string, string>;
+/**
+ * OpenAI supported audio formats for STT API
+ */
+export declare const OPENAI_SUPPORTED_FORMATS: string[];
+/**
+ * Determines the appropriate file extension for an audio MIME type
+ * @param mimeType - The MIME type of the audio
+ * @returns The file extension (without dot) or null if unsupported
+ */
+export declare function getAudioFormatFromMimeType(mimeType: string): string | null;
+/**
+ * Checks if an audio MIME type is supported by OpenAI
+ * @param mimeType - The MIME type to check
+ * @returns True if supported, false otherwise
+ */
+export declare function isAudioFormatSupported(mimeType: string): boolean;
+/**
+ * Gets a human-readable list of supported audio formats
+ * @returns Formatted string of supported formats
+ */
+export declare function getSupportedFormatsList(): string;

package/dist/utils/audioFormats.js

@@ -0,0 +1,67 @@
+/**
+ * Maps audio MIME types to their corresponding file extensions
+ * OpenAI supports: mp3, mp4, mpeg, mpga, m4a, wav, webm
+ */
+export const AUDIO_MIME_TO_EXTENSION = {
+    'audio/mpeg': 'mp3',
+    'audio/mp3': 'mp3',
+    'audio/mp4': 'mp4',
+    'audio/m4a': 'm4a',
+    'audio/wav': 'wav',
+    'audio/wave': 'wav',
+    'audio/x-wav': 'wav',
+    'audio/webm': 'webm',
+    'audio/ogg': 'webm', // Convert ogg to webm for OpenAI compatibility
+    'audio/aac': 'm4a', // Convert aac to m4a for OpenAI compatibility
+    'audio/x-aac': 'm4a',
+    'audio/3gpp': 'mp4', // Convert 3gpp to mp4
+    'audio/3gpp2': 'mp4',
+    'audio/amr': 'mp4', // Convert amr to mp4
+    'audio/amr-wb': 'mp4',
+    'audio/flac': 'wav', // Convert flac to wav
+    'audio/x-flac': 'wav',
+    'audio/opus': 'webm', // Convert opus to webm
+    'audio/x-opus': 'webm',
+};
+/**
+ * OpenAI supported audio formats for STT API
+ */
+export const OPENAI_SUPPORTED_FORMATS = ['mp3', 'mp4', 'mpeg', 'mpga', 'm4a', 'wav', 'webm'];
+/**
+ * Determines the appropriate file extension for an audio MIME type
+ * @param mimeType - The MIME type of the audio
+ * @returns The file extension (without dot) or null if unsupported
+ */
+export function getAudioFormatFromMimeType(mimeType) {
+    const normalizedMimeType = mimeType.toLowerCase();
+    // Try to get format from MIME type mapping first
+    let format = AUDIO_MIME_TO_EXTENSION[normalizedMimeType];
+    // If no mapping found, try to extract from MIME type
+    if (!format && normalizedMimeType.includes('audio/')) {
+        format = normalizedMimeType.replace('audio/', '');
+    }
+    // Handle special cases
+    if (format === 'mpeg') {
+        format = 'mp3'; // OpenAI expects mp3, not mpeg
+    }
+    // Validate the format
+    if (!format || !OPENAI_SUPPORTED_FORMATS.includes(format)) {
+        return null;
+    }
+    return format;
+}
+/**
+ * Checks if an audio MIME type is supported by OpenAI
+ * @param mimeType - The MIME type to check
+ * @returns True if supported, false otherwise
+ */
+export function isAudioFormatSupported(mimeType) {
+    return getAudioFormatFromMimeType(mimeType) !== null;
+}
+/**
+ * Gets a human-readable list of supported audio formats
+ * @returns Formatted string of supported formats
+ */
+export function getSupportedFormatsList() {
+    return OPENAI_SUPPORTED_FORMATS.join(', ');
+}

package/dist/utils/difficultyConverter.js

@@ -6,5 +6,5 @@ export function getDifficultyLabel(difficulty) {
     return codes[difficulty];
 }
 export function getNeighborDifficultyLevel(difficulty, difficultyAdjustment) {
-    return getDifficultyLabel(getDifficultyLevel(difficulty) + difficultyAdjustment);
+    return getDifficultyLabel(getDifficultyLevel(difficulty) + difficultyAdjustment - 1);
 }

package/dist/utils/endpoint.d.ts

@@ -0,0 +1,2 @@
+export declare const DEFAULT_ENDPOINT = "https://pheptqdoqsdnadgoihvr.supabase.co";
+export declare const DEFAULT_ANON_KEY = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6InBoZXB0cWRvcXNkbmFkZ29paHZyIiwicm9sZSI6ImFub24iLCJpYXQiOjE3MzE2OTY2ODcsImV4cCI6MjA0NzI3MjY4N30.4GPFAXTF8685FaXISdAPNCIM-H3RGLo8GbyhQpu1mP0";

package/dist/utils/endpoint.js

@@ -0,0 +1,2 @@
+export const DEFAULT_ENDPOINT = "https://pheptqdoqsdnadgoihvr.supabase.co";
+export const DEFAULT_ANON_KEY = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6InBoZXB0cWRvcXNkbmFkZ29paHZyIiwicm9sZSI6ImFub24iLCJpYXQiOjE3MzE2OTY2ODcsImV4cCI6MjA0NzI3MjY4N30.4GPFAXTF8685FaXISdAPNCIM-H3RGLo8GbyhQpu1mP0";

package/dist/worker/WorkerSetup.d.ts

@@ -1,6 +1,7 @@
 import { RimoriClient } from "../plugin/RimoriClient";
 /**
  * Sets up the web worker for the plugin to be able receive and send messages to Rimori.
- * @param init - The function containing the subscription logic.
+ * @param pluginId - The id of the plugin to setup the worker for.
+ * @param init - The function containing the initialization logic.
  */
-export declare function setupWorker(init: (controller: RimoriClient) => void | Promise<void>): void;
+export declare function setupWorker(pluginId: string, init: (client: RimoriClient) => void | Promise<void>): Promise<void>;