@rimori/client 1.0.3 → 1.0.4

package/src/controller/ObjectController.ts

@@ -1,5 +1,3 @@
-import { env } from "../utils/constants";
-
 type PrimitiveType = 'string' | 'number' | 'boolean';
 
 // This is the type that can appear in the `type` property
@@ -35,8 +33,8 @@ export interface ObjectRequest {
     instructions: string;
 }
 
-export async function generateObject(request: ObjectRequest, token: string) {
-    return await fetch(`${env.SUPABASE_URL}/functions/v1/llm-object`, {
+export async function generateObject(supabaseUrl: string, request: ObjectRequest, token: string) {
+    return await fetch(`${supabaseUrl}/functions/v1/llm-object`, {
         method: 'POST',
         body: JSON.stringify({
             stream: false,
@@ -51,9 +49,9 @@ export async function generateObject(request: ObjectRequest, token: string) {
 // TODO adjust stream to work with object
 export type OnLLMResponse = (id: string, response: string, finished: boolean, toolInvocations?: any[]) => void;
 
-export async function streamObject(request: ObjectRequest, onResponse: OnLLMResponse, token: string) {
+export async function streamObject(supabaseUrl: string, request: ObjectRequest, onResponse: OnLLMResponse, token: string) {
     const messageId = Math.random().toString(36).substring(3);
-    const response = await fetch(`${env.SUPABASE_URL}/functions/v1/llm-object`, {
+    const response = await fetch(`${supabaseUrl}/functions/v1/llm-object`, {
         method: 'POST',
         body: JSON.stringify({
             stream: true,

package/src/controller/SettingsController.ts

@@ -3,7 +3,7 @@ import { LanguageLevel } from "../utils/difficultyConverter";
 
 type SettingsType = "user" | "system" | "plugin";
 
-export interface UserSettings {
+export interface UserInfo {
     motherTongue: string;
     languageLevel: LanguageLevel;
     contextMenuOnSelect: boolean;
@@ -45,6 +45,14 @@ export class SettingsController {
         await this.supabase.from("plugin_settings").upsert({ plugin_id: this.pluginId, settings });
     }
 
+    public async getUserInfo(): Promise<UserInfo> {
+        return this.getSettings<UserInfo>({
+            motherTongue: "sv",
+            languageLevel: "A1",
+            contextMenuOnSelect: true,
+        }, "user");
+    }
+
     /**
      * Get the settings for the plugin. T can be any type of settings, UserSettings or SystemSettings.
      * @param defaultSettings The default settings to use if no settings are found.

package/src/controller/SharedContentController.ts

@@ -24,14 +24,14 @@ export class SharedContentController {
         filter?: { column: string, value: string | number | boolean },
     ): Promise<R[]> {
         const queryParameter = { filter_column: filter?.column || null, filter_value: filter?.value || null, unread: true }
-        const { data: newAssignments } = await this.rimoriClient.rpc(type + "_entries", queryParameter)
+        const { data: newAssignments } = await this.rimoriClient.db.rpc(type + "_entries", queryParameter)
         console.log('newAssignments:', newAssignments);
 
         if ((newAssignments as any[]).length > 0) {
             return newAssignments as R[];
         }
         // generate new assignments
-        const { data: oldAssignments } = await this.rimoriClient.rpc(type + "_entries", { ...queryParameter, unread: false })
+        const { data: oldAssignments } = await this.rimoriClient.db.rpc(type + "_entries", { ...queryParameter, unread: false })
         console.log('oldAssignments:', oldAssignments);
         const reservedTopics = this.getReservedTopics(oldAssignments as BasicAssignment[]);
 
@@ -39,7 +39,7 @@ export class SharedContentController {
         if (!request.tool.keywords || !request.tool.topic) {
             throw new Error("topic or keywords not found in the request schema");
         }
-        const instructions = await this.rimoriClient.generateObject(request);
+        const instructions = await this.rimoriClient.llm.getObject(request);
         console.log('instructions:', instructions);
 
         const preparedData = {
@@ -47,7 +47,7 @@ export class SharedContentController {
             ...instructions,
             keywords: this.purifyStringArray(instructions.keywords),
         };
-        return await this.rimoriClient.from(type).insert(preparedData).then(() => [preparedData] as R[]);
+        return await this.rimoriClient.db.from(type).insert(preparedData).then(() => [preparedData] as R[]);
     }
 
     private getReservedTopics(oldAssignments: BasicAssignment[]) {
@@ -62,10 +62,10 @@ export class SharedContentController {
     }
 
     public async getSharedContent<T extends BasicAssignment>(type: string, id: string): Promise<T> {
-        return await this.rimoriClient.from(type).select().eq('id', id).single() as unknown as T;
+        return await this.rimoriClient.db.from(type).select().eq('id', id).single() as unknown as T;
     }
 
     public async completeSharedContent(type: string, assignmentId: string) {
-        await this.rimoriClient.from(type + "_result").insert({ assignment_id: assignmentId });
+        await this.rimoriClient.db.from(type + "_result").insert({ assignment_id: assignmentId });
     }
 }

package/src/core.ts

@@ -0,0 +1,10 @@
+// Core functionality exports
+export * from "./controller/AIController";
+export * from "./controller/SharedContentController";
+export * from "./controller/SettingsController";
+export * from "./plugin/RimoriClient";
+export * from "./plugin/PluginController";
+export * from "./utils/difficultyConverter";
+export * from "./utils/PluginUtils";
+export * from "./worker/WorkerSetup";
+export * from "./plugin/fromRimori/EventBus";

package/src/hooks/UseChatHook.ts

@@ -5,10 +5,10 @@ import { ToolInvocation, Tool, Message } from "../controller/AIController";
 export function useChat(tools?: Tool[]) {
     const [messages, setMessages] = React.useState<Message[]>([]);
     const [isLoading, setIsLoading] = React.useState(false);
-    const { getAIResponseStream } = usePlugin();
+    const { llm } = usePlugin();
 
     const append = (appendMessages: Message[]) => {
-        getAIResponseStream([...messages, ...appendMessages], (id, message, finished: boolean, toolInvocations?: ToolInvocation[]) => {
+        llm.getSteamedText([...messages, ...appendMessages], (id, message, finished: boolean, toolInvocations?: ToolInvocation[]) => {
             const lastMessage = messages[messages.length - 1];
             setIsLoading(!finished);
 

package/src/index.ts

@@ -1,3 +1,6 @@
+// Re-export everything
+export * from './core';
+export * from './components';
 export * from "./components/MarkdownEditor";
 export * from "./components/CRUDModal";
 export * from "./components/Spinner";
@@ -8,8 +11,7 @@ export * from "./controller/SettingsController";
 export * from "./hooks/UseChatHook";
 export * from "./plugin/RimoriClient";
 export * from "./plugin/ThemeSetter";
-export * from "./providers/EventEmitter";
-export * from "./providers/EventEmitterContext";
 export * from "./providers/PluginProvider";
 export * from "./utils/difficultyConverter";
 export * from "./utils/PluginUtils";
+export * from "./plugin/PluginController";

package/src/plugin/PluginController.ts

@@ -1,6 +1,9 @@
-import { Child } from "ibridge-flex";
 import { createClient, SupabaseClient } from '@supabase/supabase-js'
 import { RimoriClient } from "./RimoriClient";
+import { EventBus, EventBusMessage } from './fromRimori/EventBus';
+import { setTheme } from './ThemeSetter';
+
+setTheme();
 
 interface SupabaseInfo {
     url: string,
@@ -12,55 +15,43 @@ interface SupabaseInfo {
 }
 
 export class PluginController {
-    private static instance: PluginController;
     private static client: RimoriClient;
-    private plugin: Child<null, null>;
-    private onceListeners: Map<string, any[]> = new Map();
-    private listeners: Map<string, any[]> = new Map();
+    private static instance: PluginController;
     private communicationSecret: string | null = null;
-    private initialized = false;
     private supabase: SupabaseClient | null = null;
     private supabaseInfo: SupabaseInfo | null = null;
+    private pluginId: string;
 
-    private constructor() {
-        // localStorage.debug = "*";
-        this.plugin = new Child({
-            triggerChild: ({ topic, data, _id }: any) => {
-                // console.log("trigger child with topic:" + topic + " and data: ", data);
-                this.onceListeners.get(topic)?.forEach((callback: any) => callback(_id, data));
-                this.onceListeners.set(topic, []);
-                this.listeners.get(topic)?.forEach((callback: any) => callback(_id, data));
-            }
+    private constructor(pluginId: string) {
+        this.pluginId = pluginId;
+        this.getClient = this.getClient.bind(this);
+
+        window.addEventListener("message", (event) => {
+            // console.log("client: message received", event);
+            const { topic, sender, data, eventId } = event.data.event as EventBusMessage;
+
+            // skip forwarding messages from own plugin
+            if (sender === pluginId) return;
+
+            EventBus.emit(sender, topic, data, eventId);
         });
 
-        this.emit = this.emit.bind(this);
-        this.onOnce = this.onOnce.bind(this);
-        this.getClient = this.getClient.bind(this);
-        this.subscribe = this.subscribe.bind(this);
-        this.internalEmit = this.internalEmit.bind(this);
-        this.request = this.request.bind(this);
+        EventBus.on("*", (event) => {
+            // skip messages which are not from the own plugin
+            if (event.sender !== this.pluginId) return;
+            if (event.topic.startsWith("self.")) return;
+            window.parent.postMessage({ event, secret: this.getSecret() }, "*")
+        });
     }
 
-    public static async getInstance(): Promise<RimoriClient> {
+    public static async getInstance(sender: string): Promise<RimoriClient> {
         if (!PluginController.instance) {
-            PluginController.instance = new PluginController();
-            await PluginController.instance.init();
-            PluginController.client = await RimoriClient.getInstance(
-                PluginController.instance
-            );
+            PluginController.instance = new PluginController(sender);
+            PluginController.client = await RimoriClient.getInstance(PluginController.instance);
         }
         return PluginController.client;
     }
 
-    async init() {
-        if (this.initialized) return;
-
-        // Wait for the plugin to be ready
-        await this.plugin.handshake().then(() => this.initialized = true).catch((error: any) => {
-            console.error("Failed to initialize the plugin communication:", error);
-        });
-    }
-
     private getSecret() {
         if (!this.communicationSecret) {
             const secret = new URLSearchParams(window.location.search).get("secret");
@@ -81,8 +72,8 @@ export class PluginController {
             return { supabase: this.supabase, tablePrefix: this.supabaseInfo.tablePrefix, pluginId: this.supabaseInfo.pluginId };
         }
 
-        this.supabaseInfo = await this.request<SupabaseInfo>("getSupabaseAccess");
-
+        const {data} = await EventBus.request<SupabaseInfo>(this.pluginId, "global.supabase.requestAccess");
+        this.supabaseInfo = data;
         this.supabase = createClient(this.supabaseInfo.url, this.supabaseInfo.key, {
             accessToken: () => Promise.resolve(this.getToken())
         });
@@ -95,14 +86,14 @@ export class PluginController {
             return this.supabaseInfo.token;
         }
 
-        const response = await this.request<{ token: string, expiration: Date }>("getSupabaseAccess");
+        const {data} = await EventBus.request<{ token: string, expiration: Date }>(this.pluginId, "global.supabase.requestAccess");
 
         if (!this.supabaseInfo) {
             throw new Error("Supabase info not found");
         }
 
-        this.supabaseInfo.token = response.token;
-        this.supabaseInfo.expiration = response.expiration;
+        this.supabaseInfo.token = data.token;
+        this.supabaseInfo.expiration = data.expiration;
 
         return this.supabaseInfo.token;
     }
@@ -115,44 +106,23 @@ export class PluginController {
         return this.supabaseInfo.url;
     }
 
-    public emit(eventName: string, data?: any) {
-        this.internalEmit(eventName, 0, data);
-    }
-
-    // the communication needs to have an id to be able to distinguish between different responses
-    private internalEmit(eventName: string, id: number, data?: any) {
-        this.init().then(() => this.plugin.emitToParent(eventName, { data, _id: id, secret: this.getSecret() }));
-    }
-
-    public subscribe(eventName: string, callback: (_id: number, data: any) => void) {
-        if (!this.listeners.has(eventName)) {
-            this.listeners.set(eventName, []);
+    public getGlobalEventTopic(preliminaryTopic: string) {
+        if (preliminaryTopic.startsWith("global.")) {
+            return preliminaryTopic;
         }
-
-        this.listeners.get(eventName)?.push(callback);
-    }
-
-    public onOnce(eventName: string, callback: (data: any) => void) {
-        if (!this.onceListeners.has(eventName)) {
-            this.onceListeners.set(eventName, []);
+        if (preliminaryTopic.startsWith("self.")) {
+            return preliminaryTopic;
+        }
+        const topicParts = preliminaryTopic.split(".");
+        if (topicParts.length === 3) {
+            if (![this.supabaseInfo?.pluginId, "global"].includes(topicParts[0])) {
+                throw new Error("The event topic must start with the plugin id or 'global'.");
+            }
+            return preliminaryTopic;
         }
 
-        this.onceListeners.get(eventName)?.push(callback);
+        const topicRoot = this.supabaseInfo?.pluginId ?? "global";
+        return `${topicRoot}.${preliminaryTopic}`;
     }
 
-    async request<T>(topic: string, data: any = {}): Promise<T> {
-        return await new Promise((resolve) => {
-            let triggered = false;
-            const id = Math.random();
-
-            this.internalEmit(topic, id, data);
-
-            this.subscribe(topic, (_id: number, data: any) => {
-                if (triggered || (_id !== id && _id !== 0)) return;
-                triggered = true;
-
-                resolve(data)
-            })
-        });
-    }
 }

package/src/plugin/RimoriClient.ts

@@ -1,5 +1,6 @@
 import { PluginController } from "./PluginController";
 import { SupabaseClient } from "@supabase/supabase-js";
+import { EventBusMessage, EventPayload } from "./fromRimori/EventBus";
 import { SettingsController } from "../controller/SettingsController";
 import { GenericSchema } from "@supabase/supabase-js/dist/module/lib/types";
 import { getSTTResponse, getTTSResponse } from "../controller/VoiceController";
@@ -8,6 +9,8 @@ import { SharedContentController, BasicAssignment } from "../controller/SharedCo
 import { streamChatGPT, Message, Tool, OnLLMResponse, generateText } from "../controller/AIController";
 import { generateObject as generateObjectFunction, ObjectRequest } from "../controller/ObjectController";
 import { getPlugins, Plugin } from "../controller/SidePluginController";
+import { UserInfo } from "../controller/SettingsController";
+import { EventBus, EventHandler } from "./fromRimori/EventBus";
 
 interface RimoriClientOptions {
     pluginController: PluginController;
@@ -16,38 +19,132 @@ interface RimoriClientOptions {
     pluginId: string;
 }
 
+interface Db {
+    from: {
+        <TableName extends string & keyof GenericSchema['Tables'], Table extends GenericSchema['Tables'][TableName]>(relation: TableName): PostgrestQueryBuilder<GenericSchema, Table, TableName>;
+        <ViewName extends string & keyof GenericSchema['Views'], View extends GenericSchema['Views'][ViewName]>(relation: ViewName): PostgrestQueryBuilder<GenericSchema, View, ViewName>;
+    };
+    rpc: <Fn extends GenericSchema['Functions'][string], FnName extends string & keyof GenericSchema['Functions']>(functionName: FnName, args?: Fn["Args"], options?: {
+        head?: boolean;
+        get?: boolean;
+        count?: "exact" | "planned" | "estimated";
+    }) => PostgrestFilterBuilder<GenericSchema, Fn["Returns"] extends any[] ? Fn["Returns"][number] extends Record<string, unknown> ? Fn["Returns"][number] : never : never, Fn["Returns"], string, null>;
+    functions: SupabaseClient["functions"];
+    storage: SupabaseClient["storage"];
+}
+
+interface PluginInterface {
+    pluginId: string;
+    tablePrefix: string;
+    setSettings: (settings: any) => Promise<void>;
+    /**
+     * Get the settings for the plugin. T can be any type of settings, UserSettings or SystemSettings.
+     * @param defaultSettings The default settings to use if no settings are found.
+     * @param genericSettings The type of settings to get.
+     * @returns The settings for the plugin. 
+     */
+    getSettings: <T extends object>(defaultSettings: T) => Promise<T>;
+    /**
+    * Fetches all installed plugins.
+    * @returns A promise that resolves to an array of plugins
+    */
+    getInstalled: () => Promise<Plugin[]>;
+    getUserInfo: () => Promise<UserInfo>;
+}
+
 export class RimoriClient {
     private static instance: RimoriClient;
     private superbase: SupabaseClient;
-    private plugin: PluginController;
-    public functions: SupabaseClient["functions"];
-    public storage: SupabaseClient["storage"];
-    public pluginId: string;
-    public tablePrefix: string;
+    private pluginController: PluginController;
     private settingsController: SettingsController;
     private sharedContentController: SharedContentController;
+    private supabaseUrl: string;
+    public db: Db;
+    public plugin: PluginInterface;
 
     private constructor(options: RimoriClientOptions) {
         this.superbase = options.supabase;
-        this.pluginId = options.pluginId;
-        this.plugin = options.pluginController;
-        this.tablePrefix = options.tablePrefix;
-        this.storage = this.superbase.storage;
-        this.functions = this.superbase.functions;
+        this.pluginController = options.pluginController;
         this.settingsController = new SettingsController(options.supabase, options.pluginId);
         this.sharedContentController = new SharedContentController(this);
+        this.supabaseUrl = this.pluginController.getSupabaseUrl();
+
         this.rpc = this.rpc.bind(this);
         this.from = this.from.bind(this);
-        this.emit = this.emit.bind(this);
-        this.request = this.request.bind(this);
-        this.subscribe = this.subscribe.bind(this);
-        this.getSettings = this.getSettings.bind(this);
-        this.setSettings = this.setSettings.bind(this);
-        this.getAIResponse = this.getAIResponse.bind(this);
-        this.generateObject = this.generateObject.bind(this);
-        this.getVoiceResponse = this.getVoiceResponse.bind(this);
-        this.getAIResponseStream = this.getAIResponseStream.bind(this);
-        this.getVoiceToTextResponse = this.getVoiceToTextResponse.bind(this);
+
+        this.db = {
+            rpc: this.rpc,
+            from: this.from,
+            storage: this.superbase.storage,
+            functions: this.superbase.functions,
+        }
+        this.plugin = {
+            pluginId: options.pluginId,
+            tablePrefix: options.tablePrefix,
+            setSettings: async (settings: any) => {
+                await this.settingsController.setSettings(settings);
+            },
+            getSettings: async <T extends object>(defaultSettings: T): Promise<T> => {
+                return await this.settingsController.getSettings<T>(defaultSettings);
+            },
+            getInstalled: async (): Promise<Plugin[]> => {
+                return getPlugins(this.superbase);
+            },
+            getUserInfo: async (): Promise<UserInfo> => {
+                return this.settingsController.getUserInfo();
+            }
+        }
+    }
+
+    public event = {
+        /**
+         * Emit an event to Rimori or a plugin. 
+         * The topic schema is:
+         * {pluginId}.{eventId}
+         * Check out the event bus documentation for more information.
+         * For triggering events from Rimori like context menu actions use the "global" keyword.
+         * @param topic The topic to emit the event on.
+         * @param data The data to emit.
+         * @param eventId The event id.
+         */
+        emit: (topic: string, data: any, eventId?: number) => {
+            const globalTopic = this.pluginController.getGlobalEventTopic(topic);
+            EventBus.emit(this.plugin.pluginId, globalTopic, data, eventId);
+        },
+        /**
+         * Request an event.
+         * @param topic The topic to request the event on.
+         * @param data The data to request.
+         * @returns The response from the event.
+         */
+        request: <T>(topic: string, data?: any): Promise<EventBusMessage<T>> => {
+            const globalTopic = this.pluginController.getGlobalEventTopic(topic);
+            return EventBus.request<T>(this.plugin.pluginId, globalTopic, data);
+        },
+        /**
+         * Subscribe to an event.
+         * @param topic The topic to subscribe to.
+         * @param callback The callback to call when the event is emitted.
+         */
+        on: <T = EventPayload>(topic: string, callback: EventHandler<T>) => {
+            EventBus.on<T>(this.pluginController.getGlobalEventTopic(topic), callback);
+        },
+        /**
+         * Subscribe to an event once.
+         * @param topic The topic to subscribe to.
+         * @param callback The callback to call when the event is emitted.
+         */
+        once: <T = EventPayload>(topic: string, callback: EventHandler<T>) => {
+            EventBus.once<T>(this.pluginController.getGlobalEventTopic(topic), callback);
+        },
+        /**
+         * Respond to an event.
+         * @param topic The topic to respond to.
+         * @param data The data to respond with.
+         */
+        respond: <T = EventPayload>(topic: string, data: EventPayload | ((data: EventBusMessage<T>) => EventPayload | Promise<EventPayload>)) => {
+            EventBus.respond(this.plugin.pluginId, this.pluginController.getGlobalEventTopic(topic), data);
+        }
     }
 
     public static async getInstance(pluginController: PluginController): Promise<RimoriClient> {
@@ -58,15 +155,15 @@ export class RimoriClient {
         return RimoriClient.instance;
     }
 
-    public from<
+    private from<
         TableName extends string & keyof GenericSchema['Tables'],
         Table extends GenericSchema['Tables'][TableName]
     >(relation: TableName): PostgrestQueryBuilder<GenericSchema, Table, TableName>
-    public from<
+    private from<
         ViewName extends string & keyof GenericSchema['Views'],
         View extends GenericSchema['Views'][ViewName]
     >(relation: ViewName): PostgrestQueryBuilder<GenericSchema, View, ViewName>
-    public from(relation: string): PostgrestQueryBuilder<GenericSchema, any, any> {
+    private from(relation: string): PostgrestQueryBuilder<GenericSchema, any, any> {
         return this.superbase.from(this.getTableName(relation));
     }
 
@@ -93,7 +190,7 @@ export class RimoriClient {
     * `"estimated"`: Uses exact count for low numbers and planned count for high
     * numbers.
     */
-    rpc<Fn extends GenericSchema['Functions'][string], FnName extends string & keyof GenericSchema['Functions']>(
+    private rpc<Fn extends GenericSchema['Functions'][string], FnName extends string & keyof GenericSchema['Functions']>(
         functionName: FnName,
         args: Fn['Args'] = {},
         options: {
@@ -116,68 +213,33 @@ export class RimoriClient {
     }
 
     private getTableName(type: string) {
-        return this.tablePrefix + "_" + type;
-    }
-
-    public subscribe(eventName: string, callback: (_id: number, data: any) => void) {
-        this.plugin.subscribe(eventName, callback);
-    }
-
-    public request<T>(eventName: string, data?: any): Promise<T> {
-        return this.plugin.request(eventName, data);
-    }
-
-    public emit(eventName: string, data: any) {
-        this.plugin.emit(eventName, data);
-    }
-
-    /**
-    * Get the settings for the plugin. T can be any type of settings, UserSettings or SystemSettings.
-    * @param defaultSettings The default settings to use if no settings are found.
-    * @param genericSettings The type of settings to get.
-    * @returns The settings for the plugin. 
-    */
-    public async getSettings<T extends object>(defaultSettings: T, genericSettings?: "user" | "system"): Promise<T> {
-        return this.settingsController.getSettings<T>(defaultSettings, genericSettings);
-    }
-
-    public async setSettings(settings: any, genericSettings?: "user" | "system") {
-        await this.settingsController.setSettings(settings, genericSettings);
-    }
-
-    public async getAIResponse(messages: Message[], tools?: Tool[]): Promise<string> {
-        const token = await this.plugin.getToken();
-        return generateText(messages, tools || [], token).then(response => response.messages[0].content[0].text);
-    }
-
-    public async getAIResponseStream(messages: Message[], onMessage: OnLLMResponse, tools?: Tool[]) {
-        const token = await this.plugin.getToken();
-        streamChatGPT(messages, tools || [], onMessage, token);
-    }
-
-    public async getVoiceResponse(text: string, voice = "alloy", speed = 1, language?: string): Promise<Blob> {
-        return getTTSResponse(
-            this.plugin.getSupabaseUrl(),
-            { input: text, voice, speed, language },
-            await this.plugin.getToken()
-        );
-    }
-
-    public getVoiceToTextResponse(file: Blob): Promise<string> {
-        return getSTTResponse(this.superbase, file);
-    }
-
-    /**
-     * Fetches all installed plugins.
-     * @returns A promise that resolves to an array of plugins
-     */
-    public async getPlugins(): Promise<Plugin[]> {
-        return getPlugins(this.superbase);
+        return this.plugin.tablePrefix + "_" + type;
     }
 
-    public async generateObject(request: ObjectRequest): Promise<any> {
-        const token = await this.plugin.getToken();
-        return generateObjectFunction(request, token);
+    public llm = {
+        getText: async (messages: Message[], tools?: Tool[]): Promise<string> => {
+            const token = await this.pluginController.getToken();
+            return generateText(this.supabaseUrl, messages, tools || [], token).then(response => response.messages[0].content[0].text);
+        },
+        getSteamedText: async (messages: Message[], onMessage: OnLLMResponse, tools?: Tool[]) => {
+            const token = await this.pluginController.getToken();
+            streamChatGPT(this.supabaseUrl, messages, tools || [], onMessage, token);
+        },
+        getVoice: async (text: string, voice = "alloy", speed = 1, language?: string): Promise<Blob> => {
+            return getTTSResponse(
+                this.pluginController.getSupabaseUrl(),
+                { input: text, voice, speed, language },
+                await this.pluginController.getToken()
+            );
+        },
+        getTextFromVoice: (file: Blob): Promise<string> => {
+            return getSTTResponse(this.superbase, file);
+        },
+        getObject: async (request: ObjectRequest): Promise<any> => {
+            const token = await this.pluginController.getToken();
+            return generateObjectFunction(this.pluginController.getSupabaseUrl(), request, token);
+        },
+        // getSteamedObject: this.generateObjectStream,
     }
 
     /**
@@ -215,6 +277,6 @@ export class RimoriClient {
     }
 
     public triggerSidebarAction(pluginId: string, actionKey: string, text?: string) {
-        this.emit("triggerSidebarAction", { pluginId, actionKey, text });
+        this.event.emit("global.sidebar.triggerAction", { pluginId, actionKey, text });
     }
 }