@rimori/client 1.2.0 → 1.3.0

package/dist/core/controller/AIController.js

@@ -32,89 +32,222 @@ export function streamChatGPT(backendUrl, messages, tools, onResponse, token) {
     return __awaiter(this, void 0, void 0, function* () {
         const messageId = Math.random().toString(36).substring(3);
         let currentMessages = [...messages];
+        console.log('Starting streamChatGPT with:', {
+            messageId,
+            messageCount: messages.length,
+            toolCount: tools.length,
+            backendUrl
+        });
         while (true) {
             const messagesForApi = currentMessages.map((_a) => {
                 var { id } = _a, rest = __rest(_a, ["id"]);
                 return rest;
             });
-            const response = yield fetch(`${backendUrl}/ai/llm`, {
-                method: 'POST',
-                body: JSON.stringify({ messages: messagesForApi, tools, stream: true }),
-                headers: { 'Authorization': `Bearer ${token}`, 'Content-Type': 'application/json' }
-            });
-            if (!response.body) {
-                console.error('No response body.');
-                return;
-            }
-            const reader = response.body.getReader();
-            const decoder = new TextDecoder('utf-8');
-            let content = "";
-            let done = false;
-            let toolInvocations = [];
-            let finishReason = "";
-            while (!done) {
-                const { value, done: readerDone } = yield reader.read();
-                if (value) {
-                    const chunk = decoder.decode(value, { stream: true });
-                    const lines = chunk.split('\n').filter(line => line.trim() !== '');
-                    for (const line of lines) {
-                        const command = line.substring(0, 1);
-                        if (command === '0') {
-                            const data = line.substring(3, line.length - 1);
-                            content += data;
-                            onResponse(messageId, content.replace(/\\n/g, '\n').replace(/\\+"/g, '"'), false);
-                        }
-                        else if (command === 'd' || command === 'e') {
-                            const eventData = JSON.parse(line.substring(2));
-                            finishReason = eventData.finishReason;
-                            done = true;
-                            break;
+            try {
+                const response = yield fetch(`${backendUrl}/ai/llm`, {
+                    method: 'POST',
+                    body: JSON.stringify({ messages: messagesForApi, tools, stream: true }),
+                    headers: { 'Authorization': `Bearer ${token}`, 'Content-Type': 'application/json' }
+                });
+                if (!response.ok) {
+                    throw new Error(`HTTP error! status: ${response.status}`);
+                }
+                if (!response.body) {
+                    console.error('No response body.');
+                    return;
+                }
+                const reader = response.body.getReader();
+                const decoder = new TextDecoder('utf-8');
+                let content = "";
+                let done = false;
+                let toolInvocations = [];
+                let currentTextId = "";
+                let isToolCallMode = false;
+                let buffer = ""; // Buffer for incomplete chunks
+                while (!done) {
+                    const { value, done: readerDone } = yield reader.read();
+                    if (value) {
+                        const chunk = decoder.decode(value, { stream: true });
+                        buffer += chunk;
+                        // Split by lines, but handle incomplete lines
+                        const lines = buffer.split('\n');
+                        // Keep the last line in buffer if it's incomplete
+                        if (lines.length > 1) {
+                            buffer = lines.pop() || "";
                         }
-                        else if (command === '9') {
-                            const toolInvocation = JSON.parse(line.substring(2));
-                            toolInvocations.push(toolInvocation);
+                        for (const line of lines) {
+                            if (line.trim() === '')
+                                continue;
+                            // Handle the new streaming format
+                            if (line.startsWith('data: ')) {
+                                const dataStr = line.substring(6); // Remove 'data: ' prefix
+                                // Handle [DONE] marker
+                                if (dataStr === '[DONE]') {
+                                    done = true;
+                                    break;
+                                }
+                                try {
+                                    const data = JSON.parse(dataStr);
+                                    // Log the first message to understand the format
+                                    if (!content && !isToolCallMode) {
+                                        console.log('First stream message received:', data);
+                                    }
+                                    switch (data.type) {
+                                        case 'start':
+                                            // Stream started, no action needed
+                                            console.log('Stream started');
+                                            break;
+                                        case 'start-step':
+                                            // Step started, no action needed
+                                            console.log('Step started');
+                                            break;
+                                        case 'reasoning-start':
+                                            // Reasoning started, no action needed
+                                            console.log('Reasoning started:', data.id);
+                                            break;
+                                        case 'reasoning-end':
+                                            // Reasoning ended, no action needed
+                                            console.log('Reasoning ended:', data.id);
+                                            break;
+                                        case 'text-start':
+                                            // Text generation started, store the ID
+                                            currentTextId = data.id;
+                                            console.log('Text generation started:', data.id);
+                                            break;
+                                        case 'text-delta':
+                                            // Text delta received, append to content
+                                            if (data.delta) {
+                                                content += data.delta;
+                                                onResponse(messageId, content, false);
+                                            }
+                                            break;
+                                        case 'text-end':
+                                            // Text generation ended
+                                            console.log('Text generation ended:', data.id);
+                                            break;
+                                        case 'finish-step':
+                                            // Step finished, no action needed
+                                            console.log('Step finished');
+                                            break;
+                                        case 'finish':
+                                            // Stream finished
+                                            console.log('Stream finished');
+                                            done = true;
+                                            break;
+                                        // Additional message types that might be present in the AI library
+                                        case 'tool-call':
+                                            // Tool call initiated
+                                            console.log('Tool call initiated:', data);
+                                            isToolCallMode = true;
+                                            if (data.toolCallId && data.toolName && data.args) {
+                                                toolInvocations.push({
+                                                    toolCallId: data.toolCallId,
+                                                    toolName: data.toolName,
+                                                    args: data.args
+                                                });
+                                            }
+                                            break;
+                                        case 'tool-call-delta':
+                                            // Tool call delta (for streaming tool calls)
+                                            console.log('Tool call delta:', data);
+                                            break;
+                                        case 'tool-call-end':
+                                            // Tool call completed
+                                            console.log('Tool call completed:', data);
+                                            break;
+                                        case 'tool-result':
+                                            // Tool execution result
+                                            console.log('Tool result:', data);
+                                            break;
+                                        case 'error':
+                                            // Error occurred
+                                            console.error('Stream error:', data);
+                                            break;
+                                        case 'usage':
+                                            // Usage information
+                                            console.log('Usage info:', data);
+                                            break;
+                                        case 'model':
+                                            // Model information
+                                            console.log('Model info:', data);
+                                            break;
+                                        case 'stop':
+                                            // Stop signal
+                                            console.log('Stop signal received');
+                                            done = true;
+                                            break;
+                                        default:
+                                            // Unknown type, log for debugging
+                                            console.log('Unknown stream type:', data.type, data);
+                                            break;
+                                    }
+                                }
+                                catch (error) {
+                                    console.error('Error parsing stream data:', error, dataStr);
+                                }
+                            }
                         }
                     }
+                    if (readerDone) {
+                        done = true;
+                    }
                 }
-                if (readerDone) {
-                    done = true;
+                // Check if we have content or if this was a tool call response
+                if (content || toolInvocations.length > 0) {
+                    currentMessages.push({
+                        id: messageId,
+                        role: "assistant",
+                        content: content,
+                        toolCalls: toolInvocations.length > 0 ? toolInvocations : undefined,
+                    });
                 }
-            }
-            if (content || toolInvocations.length > 0) {
-                currentMessages.push({
-                    id: messageId,
-                    role: "assistant",
-                    content: content,
-                    toolCalls: toolInvocations.length > 0 ? toolInvocations : undefined,
-                });
-            }
-            if (finishReason !== 'tool-calls') {
-                onResponse(messageId, content.replace(/\\n/g, '\n'), true, toolInvocations);
-                return;
-            }
-            const toolResults = [];
-            for (const toolInvocation of toolInvocations) {
-                const tool = tools.find(t => t.name === toolInvocation.toolName);
-                if (tool && tool.execute) {
-                    try {
-                        const result = yield tool.execute(toolInvocation.args);
-                        toolResults.push({
-                            id: Math.random().toString(36).substring(3),
-                            role: "user",
-                            content: `Tool '${toolInvocation.toolName}' returned: ${JSON.stringify(result)}`,
-                        });
+                // Handle tool call scenario if tools were provided
+                if (tools.length > 0 && toolInvocations.length > 0) {
+                    console.log('Tool calls detected, executing tools...');
+                    const toolResults = [];
+                    for (const toolInvocation of toolInvocations) {
+                        const tool = tools.find(t => t.name === toolInvocation.toolName);
+                        if (tool && tool.execute) {
+                            try {
+                                const result = yield tool.execute(toolInvocation.args);
+                                toolResults.push({
+                                    id: Math.random().toString(36).substring(3),
+                                    role: "user",
+                                    content: `Tool '${toolInvocation.toolName}' returned: ${JSON.stringify(result)}`,
+                                });
+                            }
+                            catch (error) {
+                                console.error(`Error executing tool ${toolInvocation.toolName}:`, error);
+                                toolResults.push({
+                                    id: Math.random().toString(36).substring(3),
+                                    role: "user",
+                                    content: `Tool '${toolInvocation.toolName}' failed with error: ${error}`,
+                                });
+                            }
+                        }
                     }
-                    catch (error) {
-                        console.error(`Error executing tool ${toolInvocation.toolName}:`, error);
-                        toolResults.push({
-                            id: Math.random().toString(36).substring(3),
-                            role: "user",
-                            content: `Tool '${toolInvocation.toolName}' failed with error: ${error}`,
-                        });
+                    if (toolResults.length > 0) {
+                        currentMessages.push(...toolResults);
+                        // Continue the loop to handle the next response
+                        continue;
                     }
                 }
+                // Since the new format doesn't seem to support tool calls in the same way,
+                // we'll assume the stream is complete when we reach the end
+                // If tools are provided and no content was generated, this might indicate a tool call
+                if (tools.length > 0 && !content && !isToolCallMode) {
+                    // This might be a tool call scenario, but we need more information
+                    // For now, we'll just finish the stream
+                    console.log('No content generated, but tools provided - might be tool call scenario');
+                }
+                onResponse(messageId, content, true, toolInvocations);
+                return;
+            }
+            catch (error) {
+                console.error('Error in streamChatGPT:', error);
+                onResponse(messageId, `Error: ${error instanceof Error ? error.message : String(error)}`, true, []);
+                return;
             }
-            currentMessages.push(...toolResults);
         }
     });
 }

package/dist/core/controller/AudioController.js

@@ -0,0 +1 @@
+"use strict";

package/dist/core/controller/ObjectController.d.ts

@@ -36,7 +36,7 @@ export interface ObjectRequest {
      */
     instructions: string;
 }
-export declare function generateObject(supabaseUrl: string, request: ObjectRequest, token: string): Promise<any>;
+export declare function generateObject(backendUrl: string, request: ObjectRequest, token: string): Promise<any>;
 export type OnLLMResponse = (id: string, response: string, finished: boolean, toolInvocations?: any[]) => void;
-export declare function streamObject(supabaseUrl: string, request: ObjectRequest, onResponse: OnLLMResponse, token: string): Promise<void>;
+export declare function streamObject(backendUrl: string, request: ObjectRequest, onResponse: OnLLMResponse, token: string): Promise<void>;
 export {};

package/dist/core/controller/ObjectController.js

@@ -7,9 +7,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-export function generateObject(supabaseUrl, request, token) {
+export function generateObject(backendUrl, request, token) {
     return __awaiter(this, void 0, void 0, function* () {
-        return yield fetch(`${supabaseUrl}/functions/v1/llm-object`, {
+        return yield fetch(`${backendUrl}/ai/llm-object`, {
             method: 'POST',
             body: JSON.stringify({
                 stream: false,
@@ -17,14 +17,14 @@ export function generateObject(supabaseUrl, request, token) {
                 behaviour: request.behaviour,
                 instructions: request.instructions,
             }),
-            headers: { 'Authorization': `Bearer ${token}` }
+            headers: { 'Authorization': `Bearer ${token}`, 'Content-Type': 'application/json' }
         }).then(response => response.json());
     });
 }
-export function streamObject(supabaseUrl, request, onResponse, token) {
+export function streamObject(backendUrl, request, onResponse, token) {
     return __awaiter(this, void 0, void 0, function* () {
         const messageId = Math.random().toString(36).substring(3);
-        const response = yield fetch(`${supabaseUrl}/functions/v1/llm-object`, {
+        const response = yield fetch(`${backendUrl}/ai/llm-object`, {
             method: 'POST',
             body: JSON.stringify({
                 stream: true,
@@ -32,7 +32,7 @@ export function streamObject(supabaseUrl, request, onResponse, token) {
                 systemInstructions: request.behaviour,
                 secondaryInstructions: request.instructions,
             }),
-            headers: { 'Authorization': `Bearer ${token}` }
+            headers: { 'Authorization': `Bearer ${token}`, 'Content-Type': 'application/json' }
         });
         if (!response.body) {
             console.error('No response body.');
@@ -56,7 +56,7 @@ export function streamObject(supabaseUrl, request, onResponse, token) {
                         content += data;
                         // console.log("AI response:", content);
                         //content \n\n should be real line break when message is displayed
-                        onResponse(messageId, content.replace(/\\n/g, '\n'), false);
+                        onResponse(messageId, content.replace(/\\n/g, '\n').replace(/\\+"/g, '"'), false);
                     }
                     else if (command === 'd') {
                         // console.log("AI usage:", JSON.parse(line.substring(2)));
@@ -71,6 +71,6 @@ export function streamObject(supabaseUrl, request, onResponse, token) {
                 }
             }
         }
-        onResponse(messageId, content.replace(/\\n/g, '\n'), true, toolInvocations);
+        onResponse(messageId, content.replace(/\\n/g, '\n').replace(/\\+"/g, '"'), true, toolInvocations);
     });
 }

package/dist/core/controller/SettingsController.d.ts

@@ -21,11 +21,27 @@ export interface UserInfo {
     study_buddy: Buddy;
     story_genre: string;
     study_duration: number;
+    /**
+     * The 2 letter language code of the language the user speaks natively.
+     * With the function getLanguageName, the language name can be retrieved.
+     */
     mother_tongue: Language;
+    /**
+     * The language the user targets to learn.
+     */
+    target_language: Language;
     motivation_type: string;
     onboarding_completed: boolean;
     context_menu_on_select: boolean;
     user_name?: string;
+    /**
+     * ISO 3166-1 alpha-2 country code of user's location (exposed to plugins)
+     */
+    location_country: string;
+    /**
+     * Optional: nearest big city (>100,000) near user's location
+     */
+    location_city?: string;
 }
 export declare class SettingsController {
     private pluginId;

package/dist/core/controller/SharedContentController.d.ts

@@ -14,14 +14,42 @@ export declare class SharedContentController {
      * @param contentType - The type of content to fetch.
      * @param generatorInstructions - The instructions for the generator. The object needs to have a tool property with a topic and keywords property to let a new unique topic be generated.
      * @param filter - An optional filter to apply to the query.
-     * @param privateTopic - An optional flag to indicate if the topic should be private and only be visible to the user.
+     * @param options - Optional options.
+     * @param options.privateTopic - If the topic should be private and only be visible to the user.
+     * @param options.skipDbSave - If true, do not persist a newly generated content to the DB (default false).
+     * @param options.alwaysGenerateNew - If true, always generate a new content even if there is already a content with the same filter.
+     * @param options.excludeIds - Optional list of shared_content ids to exclude from selection.
      * @returns The new shared content.
      */
-    getNewSharedContent<T>(contentType: string, generatorInstructions: SharedContentObjectRequest, filter?: SharedContentFilter, privateTopic?: boolean): Promise<SharedContent<T>>;
+    getNewSharedContent<T>(contentType: string, generatorInstructions: SharedContentObjectRequest, filter?: SharedContentFilter, options?: {
+        privateTopic?: boolean;
+        skipDbSave?: boolean;
+        alwaysGenerateNew?: boolean;
+        excludeIds?: string[];
+    }): Promise<SharedContent<T>>;
+    private generateNewAssignment;
     private getGeneratorInstructions;
     private getCompletedTopics;
     getSharedContent<T>(contentType: string, id: string): Promise<SharedContent<T>>;
     completeSharedContent(contentType: string, assignmentId: string): Promise<void>;
+    /**
+     * Update state details for a shared content entry in shared_content_completed.
+     * Assumes table has columns: state ('completed'|'ongoing'|'hidden'), reaction ('liked'|'disliked'|null), bookmarked boolean.
+     * Upserts per (id, content_type, user).
+     * @param param
+     * @param param.contentType - The content type.
+     * @param param.id - The shared content id.
+     * @param param.state - The state to set.
+     * @param param.reaction - Optional reaction.
+     * @param param.bookmarked - Optional bookmark flag.
+     */
+    updateSharedContentState({ contentType, id, state, reaction, bookmarked, }: {
+        contentType: string;
+        id: string;
+        state?: 'completed' | 'ongoing' | 'hidden';
+        reaction?: 'liked' | 'disliked' | null;
+        bookmarked?: boolean;
+    }): Promise<void>;
     /**
      * Fetch shared content from the database based on optional filters.
      * @param contentType - The type of content to fetch.

package/dist/core/controller/SharedContentController.js

@@ -17,49 +17,63 @@ export class SharedContentController {
      * @param contentType - The type of content to fetch.
      * @param generatorInstructions - The instructions for the generator. The object needs to have a tool property with a topic and keywords property to let a new unique topic be generated.
      * @param filter - An optional filter to apply to the query.
-     * @param privateTopic - An optional flag to indicate if the topic should be private and only be visible to the user.
+     * @param options - Optional options.
+     * @param options.privateTopic - If the topic should be private and only be visible to the user.
+     * @param options.skipDbSave - If true, do not persist a newly generated content to the DB (default false).
+     * @param options.alwaysGenerateNew - If true, always generate a new content even if there is already a content with the same filter.
+     * @param options.excludeIds - Optional list of shared_content ids to exclude from selection.
      * @returns The new shared content.
      */
     getNewSharedContent(contentType, generatorInstructions, 
     //this filter is there if the content should be filtered additionally by a column and value
-    filter, privateTopic) {
+    filter, options) {
         return __awaiter(this, void 0, void 0, function* () {
-            const query = this.supabase.from("shared_content")
-                .select("*, scc:shared_content_completed(id)")
+            let query = this.supabase.from("shared_content")
+                .select("*, scc:shared_content_completed(id, state)")
                 .eq('content_type', contentType)
-                .is('scc.id', null)
-                .is('deleted_at', null)
-                .limit(10);
+                .not('scc.state', 'in', '("completed","ongoing","hidden")')
+                .is('deleted_at', null);
+            if ((options === null || options === void 0 ? void 0 : options.excludeIds) && options.excludeIds.length > 0) {
+                const excludeIds = options.excludeIds.filter((id) => !id.startsWith('internal-temp-id-'));
+                // Supabase expects raw PostgREST syntax like '("id1","id2")'.
+                const excludeList = `(${excludeIds.map((id) => `"${id}"`).join(',')})`;
+                query = query.not('id', 'in', excludeList);
+            }
             if (filter) {
                 query.contains('data', filter);
             }
-            const { data: newAssignments, error } = yield query;
+            const { data: newAssignments, error } = yield query.limit(30);
             if (error) {
                 console.error('error fetching new assignments:', error);
                 throw new Error('error fetching new assignments');
             }
-            console.log('newAssignments:', newAssignments);
-            if (newAssignments.length > 0) {
+            // console.log('newAssignments:', newAssignments);
+            if (!(options === null || options === void 0 ? void 0 : options.alwaysGenerateNew) && newAssignments.length > 0) {
                 const index = Math.floor(Math.random() * newAssignments.length);
                 return newAssignments[index];
             }
-            // generate new assignments
-            const fullInstructions = yield this.getGeneratorInstructions(contentType, generatorInstructions, filter);
-            console.log('fullInstructions:', fullInstructions);
-            const instructions = yield this.rimoriClient.ai.getObject(fullInstructions);
+            const instructions = yield this.generateNewAssignment(contentType, generatorInstructions, filter);
             console.log('instructions:', instructions);
-            const { data: newAssignment, error: insertError } = yield this.supabase.from("shared_content").insert({
-                private: privateTopic,
-                content_type: contentType,
+            //create the shared content object
+            const data = {
+                id: "internal-temp-id-" + Math.random().toString(36).substring(2, 15),
+                contentType,
                 title: instructions.title,
                 keywords: instructions.keywords.map(({ text }) => text),
                 data: Object.assign(Object.assign(Object.assign({}, instructions), { title: undefined, keywords: undefined }), generatorInstructions.fixedProperties),
-            }).select();
-            if (insertError) {
-                console.error('error inserting new assignment:', insertError);
-                throw new Error('error inserting new assignment');
+                privateTopic: options === null || options === void 0 ? void 0 : options.privateTopic,
+            };
+            if (options === null || options === void 0 ? void 0 : options.skipDbSave) {
+                return data;
             }
-            return newAssignment[0];
+            return yield this.createSharedContent(data);
+        });
+    }
+    generateNewAssignment(contentType, generatorInstructions, filter) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const fullInstructions = yield this.getGeneratorInstructions(contentType, generatorInstructions, filter);
+            console.log('fullInstructions:', fullInstructions);
+            return yield this.rimoriClient.ai.getObject(fullInstructions);
         });
     }
     getGeneratorInstructions(contentType, generatorInstructions, filter) {
@@ -108,7 +122,44 @@ export class SharedContentController {
     }
     completeSharedContent(contentType, assignmentId) {
         return __awaiter(this, void 0, void 0, function* () {
-            yield this.supabase.from("shared_content_completed").insert({ content_type: contentType, id: assignmentId });
+            // Idempotent completion: upsert on (id, user_id) so repeated calls don't fail
+            const { error } = yield this.supabase
+                .from("shared_content_completed")
+                .upsert({ content_type: contentType, id: assignmentId }, { onConflict: 'id' });
+            if (error) {
+                console.error('error completing shared content:', error);
+                throw new Error('error completing shared content');
+            }
+        });
+    }
+    /**
+     * Update state details for a shared content entry in shared_content_completed.
+     * Assumes table has columns: state ('completed'|'ongoing'|'hidden'), reaction ('liked'|'disliked'|null), bookmarked boolean.
+     * Upserts per (id, content_type, user).
+     * @param param
+     * @param param.contentType - The content type.
+     * @param param.id - The shared content id.
+     * @param param.state - The state to set.
+     * @param param.reaction - Optional reaction.
+     * @param param.bookmarked - Optional bookmark flag.
+     */
+    updateSharedContentState(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ contentType, id, state, reaction, bookmarked, }) {
+            const payload = { content_type: contentType, id };
+            if (state !== undefined)
+                payload.state = state;
+            if (reaction !== undefined)
+                payload.reaction = reaction;
+            if (bookmarked !== undefined)
+                payload.bookmarked = bookmarked;
+            // Prefer upsert, fall back to insert/update if upsert not allowed
+            const { error } = yield this.supabase
+                .from('shared_content_completed')
+                .upsert(payload, { onConflict: 'id' });
+            if (error) {
+                console.error('error updating shared content state:', error);
+                throw new Error('error updating shared content state');
+            }
         });
     }
     /**

package/dist/core/controller/VoiceController.d.ts

@@ -1,6 +1,5 @@
-import { SupabaseClient } from "@supabase/supabase-js";
-export declare function getSTTResponse(supabase: SupabaseClient, audio: Blob): Promise<any>;
-export declare function getTTSResponse(supabaseUrl: string, request: TTSRequest, token: string): Promise<Blob>;
+export declare function getSTTResponse(backendUrl: string, audio: Blob, token: string): Promise<any>;
+export declare function getTTSResponse(backendUrl: string, request: TTSRequest, token: string): Promise<Blob>;
 interface TTSRequest {
     input: string;
     voice: string;

package/dist/core/controller/VoiceController.js

@@ -7,16 +7,23 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-export function getSTTResponse(supabase, audio) {
+export function getSTTResponse(backendUrl, audio, token) {
     return __awaiter(this, void 0, void 0, function* () {
         const formData = new FormData();
         formData.append('file', audio);
-        return yield supabase.functions.invoke('speech', { method: 'POST', body: formData }).then(({ data }) => data.text);
+        return yield fetch(`${backendUrl}/voice/stt`, {
+            method: 'POST',
+            headers: { 'Authorization': `Bearer ${token}` },
+            body: formData,
+        }).then(r => r.json()).then(r => {
+            // console.log("STT response: ", r);
+            return r.text;
+        });
     });
 }
-export function getTTSResponse(supabaseUrl, request, token) {
+export function getTTSResponse(backendUrl, request, token) {
     return __awaiter(this, void 0, void 0, function* () {
-        return yield fetch(`${supabaseUrl}/functions/v1/speech`, {
+        return yield fetch(`${backendUrl}/voice/tts`, {
             method: 'POST',
             headers: {
                 'Content-Type': 'application/json',

package/dist/core/core.d.ts

@@ -11,3 +11,4 @@ export { SharedContent } from "./controller/SharedContentController";
 export { Message, OnLLMResponse, ToolInvocation } from "./controller/AIController";
 export { MacroAccomplishmentPayload, MicroAccomplishmentPayload } from "../plugin/AccomplishmentHandler";
 export { Tool } from "../fromRimori/PluginTypes";
+export { SharedContentObjectRequest } from "./controller/SharedContentController";

package/dist/fromRimori/EventBus.js

@@ -11,7 +11,7 @@ export class EventBusHandler {
     constructor() {
         this.listeners = new Map();
         this.responseResolvers = new Map();
-        this.debugEnabled = true;
+        this.debugEnabled = false;
         this.evName = "";
         //private constructor
     }