@rimori/client 1.2.0 → 1.3.0

package/dist/plugin/RimoriClient.js

@@ -8,7 +8,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import { generateText, streamChatGPT } from "../core/controller/AIController";
-import { generateObject as generateObjectFunction } from "../core/controller/ObjectController";
+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";
@@ -91,6 +91,11 @@ export class RimoriClient {
              */
             emitSidebarAction: (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.navigation = {
@@ -109,17 +114,24 @@ export class RimoriClient {
             }),
             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.
@@ -151,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.
@@ -182,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.
@@ -192,18 +216,16 @@ export class RimoriClient {
                 })
             }
         };
+        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(info.pluginId);
-        this.installedPlugins = info.installedPlugins;
-        this.profile = info.profile;
         this.from = this.from.bind(this);
         this.db = {
             from: this.from,
-            storage: this.superbase.storage,
+            // storage: this.superbase.storage,
             // functions: this.superbase.functions,
             tablePrefix: info.tablePrefix,
             getTableName: this.getTableName.bind(this),
@@ -216,14 +238,26 @@ export class RimoriClient {
             getSettings: (defaultSettings) => __awaiter(this, void 0, void 0, function* () {
                 return yield this.settingsController.getSettings(defaultSettings);
             }),
-            getInstalled: () => __awaiter(this, void 0, void 0, function* () {
-                return this.installedPlugins;
-            }),
-            getUserInfo: () => __awaiter(this, void 0, void 0, function* () {
-                return this.profile;
-            })
+            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) {
@@ -236,10 +270,13 @@ export class RimoriClient {
     from(relation) {
         return this.superbase.from(this.getTableName(relation));
     }
-    getTableName(type) {
-        if (type.startsWith("global_")) {
-            return type.replace("global_", "");
+    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 + "_" + type;
+        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

@@ -24,6 +24,7 @@ export class StandaloneClient {
                 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,18 +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", {
-                    body: { pluginId },
-                    headers: { authorization: `Bearer ${(_a = session.data.session) === null || _a === void 0 ? void 0 : _a.access_token}` },
+                // 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 (error) {
-                    throw new Error("Failed to get plugin token. " + error.message);
+                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,2 +1,2 @@
-export declare function setTheme(): void;
-export declare function isDarkTheme(): boolean;
+export declare function setTheme(theme?: string | null): void;
+export declare function isDarkTheme(theme?: string | null): boolean;

package/dist/plugin/ThemeSetter.js

@@ -1,14 +1,17 @@
-export function setTheme() {
+export function setTheme(theme) {
     document.documentElement.classList.add("dark:text-gray-200");
-    if (isDarkTheme()) {
+    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() {
-    const urlParams = new URLSearchParams(window.location.search);
-    let theme = urlParams.get('theme');
+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;
     }

package/dist/providers/PluginProvider.d.ts

@@ -8,5 +8,5 @@ interface PluginProviderProps {
     };
 }
 export declare const PluginProvider: React.FC<PluginProviderProps>;
-export declare const usePlugin: () => RimoriClient;
+export declare const useRimori: () => RimoriClient;
 export {};

package/dist/providers/PluginProvider.js

@@ -17,27 +17,40 @@ const PluginContext = createContext(null);
 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, settings }) => {
     if (!plugin) {
         return "";
     }
-    return (_jsxs(PluginContext.Provider, { value: plugin, children: [!(settings === null || settings === void 0 ? void 0 : settings.disableContextMenu) && _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/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/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>;

package/dist/worker/WorkerSetup.js

@@ -7,76 +7,31 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { EventBus, EventBusHandler } from "../fromRimori/EventBus";
+import { EventBusHandler } from "../fromRimori/EventBus";
 import { PluginController } from "../plugin/PluginController";
-let controller = null;
-const listeners = [];
-let debugEnabled = false;
 /**
  * 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 function setupWorker(init) {
-    // Mock of the window object for the worker context to be able to use the PluginController.
-    const mockWindow = {
-        isWorker: true,
-        location: { search: '?secret=123' },
-        parent: {
-            postMessage: (message) => {
-                message.event.sender = "worker." + message.event.sender;
-                checkDebugMode(message.event);
-                logIfDebug('sending event to Rimori', message.event);
-                self.postMessage(message);
-            }
-        },
-        addEventListener: (_, listener) => {
-            listeners.push(listener);
-        },
-        APP_CONFIG: {
-            SUPABASE_URL: 'NOT_SET',
-            SUPABASE_ANON_KEY: 'NOT_SET',
-            BACKEND_URL: 'NOT_SET',
-        },
-    };
-    // Assign the mock to globalThis.
-    Object.assign(globalThis, { window: mockWindow });
-    EventBusHandler.getInstance("Worker EventBus");
-    // Handle init message from Rimori.
-    self.onmessage = (response) => __awaiter(this, void 0, void 0, function* () {
-        checkDebugMode(response.data);
-        logIfDebug('Message received', response.data);
-        const event = response.data;
-        if (event.topic === 'global.worker.requestInit') {
-            if (!controller) {
-                mockWindow.APP_CONFIG.SUPABASE_URL = event.data.supabaseUrl;
-                mockWindow.APP_CONFIG.SUPABASE_ANON_KEY = event.data.supabaseAnonKey;
-                mockWindow.APP_CONFIG.BACKEND_URL = event.data.backendUrl;
-                controller = yield PluginController.getInstance(event.data.pluginId);
-                logIfDebug('Worker initialized.');
-                yield init(controller);
-                logIfDebug('Plugin listeners initialized.');
-            }
-            const initEvent = {
-                timestamp: new Date().toISOString(),
-                eventId: event.eventId,
-                sender: "worker." + event.sender,
-                topic: 'global.worker.requestInit',
-                data: { success: true },
-                debug: debugEnabled
-            };
-            return self.postMessage({ secret: "123", event: initEvent });
-        }
-        listeners.forEach(listener => listener({ data: { event: response.data, secret: "123" } }));
+export function setupWorker(pluginId, init) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // Mock of the window object for the worker context to be able to use the PluginController.
+        const mockWindow = {
+            isWorker: true,
+            location: {},
+            parent: {
+                postMessage: () => { }
+            },
+            addEventListener: () => { }
+        };
+        // Assign the mock to globalThis.
+        Object.assign(globalThis, { window: mockWindow });
+        EventBusHandler.getInstance("Worker EventBus");
+        const rimoriClient = yield PluginController.getInstance(pluginId);
+        console.debug('[Worker] RimoriClient initialized.');
+        yield init(rimoriClient);
+        console.debug('[Worker] Worker initialized.');
+        self.postMessage({ type: "rimori:acknowledged", pluginId: pluginId });
     });
 }
-function checkDebugMode(event) {
-    if (event.topic === 'global.system.requestDebug' || event.debug) {
-        debugEnabled = true;
-        EventBus.emit("worker", "global.system.requestDebug");
-    }
-}
-function logIfDebug(...args) {
-    if (debugEnabled) {
-        console.debug('[Worker] ' + args[0], ...args.slice(1));
-    }
-}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rimori/client",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "bin": {
@@ -35,6 +35,7 @@
     "@supabase/supabase-js": "^2.48.1",
     "@tiptap/react": "2.10.3",
     "@tiptap/starter-kit": "2.10.3",
+    "html2canvas": "^1.4.1",
     "react-icons": "^5.4.0",
     "react-markdown": "^10.1.0",
     "tiptap-markdown": "^0.8.10"

package/src/cli/scripts/init/dev-registration.ts

@@ -157,7 +157,6 @@ export async function registerDeveloper(jwtToken: string, port: number): Promise
   console.log('🚀 Registering developer and creating plugin...');
 
   try {
-    console.log('port', port, typeof port);
     const currentFolderName = path.basename(process.cwd());
     const body: any = { port, pluginName: currentFolderName };
     const backendUrl = process.env.RIMORI_BACKEND_URL || "https://api.rimori.se";

package/src/cli/scripts/init/main.ts

@@ -15,6 +15,7 @@ import { updatePackageJson, type PackageJson } from './package-setup.js';
 import { transformAppRouter } from './router-transformer.js';
 import { updateTailwindConfig } from './tailwind-config.js';
 import { updateViteConfigBase } from './vite-config.js';
+import 'dotenv/config';
 
 /**
  * Main function that handles the complete plugin setup flow.

package/src/components/ai/Assistant.tsx

@@ -4,7 +4,7 @@ import { AudioInputField } from './EmbeddedAssistent/AudioInputField';
 import { MessageSender } from './EmbeddedAssistent/TTS/MessageSender';
 import Markdown from 'react-markdown';
 import { useChat } from '../../hooks/UseChatHook';
-import { usePlugin } from '../../components';
+import { useRimori } from '../../components';
 import { FirstMessages, getFirstMessages } from './utils';
 
 interface Props {
@@ -16,7 +16,7 @@ interface Props {
 
 export function AssistantChat({ avatarImageUrl, voiceId, onComplete, autoStartConversation }: Props) {
     const [oralCommunication, setOralCommunication] = React.useState(true);
-    const { ai: llm, event } = usePlugin();
+    const { ai: llm, event } = useRimori();
     const sender = useMemo(() => new MessageSender(llm.getVoice, voiceId), []);
     const { messages, append, isLoading, setMessages } = useChat();
 

package/src/components/ai/Avatar.tsx

@@ -4,7 +4,7 @@ import { MessageSender } from './EmbeddedAssistent/TTS/MessageSender';
 import { CircleAudioAvatar } from './EmbeddedAssistent/CircleAudioAvatar';
 import { Tool } from '../../fromRimori/PluginTypes';
 import { useChat } from '../../hooks/UseChatHook';
-import { usePlugin } from '../../components';
+import { useRimori } from '../../components';
 import { getFirstMessages } from './utils';
 import { FirstMessages } from './utils';
 
@@ -29,7 +29,7 @@ export function Avatar({
   circleSize = "300px",
   className
 }: Props) {
-  const { ai, event } = usePlugin();
+  const { ai, event } = useRimori();
   const [agentReplying, setAgentReplying] = useState(false);
   const [isProcessingMessage, setIsProcessingMessage] = useState(false);
   const sender = useMemo(() => new MessageSender(ai.getVoice, voiceId), [voiceId]);