@rimori/react-client 0.1.0

package/dist/rimori-client/src/controller/ObjectController.d.ts

@@ -0,0 +1,42 @@
+type PrimitiveType = 'string' | 'number' | 'boolean';
+type ObjectToolParameterType = PrimitiveType | {
+    [key: string]: ObjectToolParameter;
+} | [{
+    [key: string]: ObjectToolParameter;
+}];
+interface ObjectToolParameter {
+    type: ObjectToolParameterType;
+    description?: string;
+    enum?: string[];
+    optional?: boolean;
+}
+/**
+ * The tools that the AI can use.
+ *
+ * The key is the name of the tool.
+ * The value is the parameter of the tool.
+ *
+ */
+export type ObjectTool = {
+    [key: string]: ObjectToolParameter;
+};
+export interface ObjectRequest {
+    /**
+     * The tools that the AI can use.
+     */
+    tool: ObjectTool;
+    /**
+     * High level instructions for the AI to follow. Behaviour, tone, restrictions, etc.
+     * Example: "Act like a recipe writer."
+     */
+    behaviour?: string;
+    /**
+     * The specific instruction for the AI to follow.
+     * Example: "Generate a recipe using chicken, rice and vegetables."
+     */
+    instructions: string;
+}
+export declare function generateObject<T = any>(backendUrl: string, request: ObjectRequest, token: string): Promise<T>;
+export type OnLLMResponse = (id: string, response: string, finished: boolean, toolInvocations?: any[]) => void;
+export declare function streamObject(backendUrl: string, request: ObjectRequest, onResponse: OnLLMResponse, token: string): Promise<void>;
+export {};

package/dist/rimori-client/src/controller/ObjectController.js

@@ -0,0 +1,76 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+export function generateObject(backendUrl, request, token) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return yield fetch(`${backendUrl}/ai/llm-object`, {
+            method: 'POST',
+            body: JSON.stringify({
+                stream: false,
+                tool: request.tool,
+                behaviour: request.behaviour,
+                instructions: request.instructions,
+            }),
+            headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/json' },
+        }).then((response) => response.json());
+    });
+}
+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(`${backendUrl}/ai/llm-object`, {
+            method: 'POST',
+            body: JSON.stringify({
+                stream: true,
+                tools: request.tool,
+                systemInstructions: request.behaviour,
+                secondaryInstructions: request.instructions,
+            }),
+            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;
+        const toolInvocations = [];
+        while (!done) {
+            const { value } = 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 data = line.substring(3, line.length - 1);
+                    const command = line.substring(0, 1);
+                    // console.log("data: ", { line, data, command });
+                    if (command === '0') {
+                        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').replace(/\\+"/g, '"'), false);
+                    }
+                    else if (command === 'd') {
+                        // console.log("AI usage:", JSON.parse(line.substring(2)));
+                        done = true;
+                        break;
+                    }
+                    else if (command === '9') {
+                        // console.log("tool call:", JSON.parse(line.substring(2)));
+                        // console.log("tools", tools);
+                        toolInvocations.push(JSON.parse(line.substring(2)));
+                    }
+                }
+            }
+        }
+        onResponse(messageId, content.replace(/\\n/g, '\n').replace(/\\+"/g, '"'), true, toolInvocations);
+    });
+}

package/dist/rimori-client/src/controller/SettingsController.d.ts

@@ -0,0 +1,79 @@
+import { SupabaseClient } from '@supabase/supabase-js';
+import { LanguageLevel } from '../utils/difficultyConverter';
+import { Guild } from '../plugin/CommunicationHandler';
+export interface Buddy {
+    id: string;
+    name: string;
+    description: string;
+    avatarUrl: string;
+    voiceId: string;
+    aiPersonality: string;
+}
+export interface Language {
+    code: string;
+    name: string;
+    native: string;
+    capitalized: string;
+    uppercase: string;
+}
+export interface UserInfo {
+    skill_level_reading: LanguageLevel;
+    skill_level_writing: LanguageLevel;
+    skill_level_grammar: LanguageLevel;
+    skill_level_speaking: LanguageLevel;
+    skill_level_listening: LanguageLevel;
+    skill_level_understanding: LanguageLevel;
+    goal_longterm: string;
+    goal_weekly: string;
+    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 target location (exposed to plugins)
+     */
+    target_country: string;
+    /**
+     * Optional: nearest big city (>100,000) near user's location
+     */
+    target_city?: string;
+}
+export declare class SettingsController {
+    private pluginId;
+    private supabase;
+    private guild;
+    constructor(supabase: SupabaseClient, pluginId: string, guild: Guild);
+    /**
+     * Fetches settings based on guild configuration.
+     * If guild doesn't allow user settings, fetches guild-level settings.
+     * Otherwise, fetches user-specific settings.
+     * @returns The settings object or null if not found.
+     */
+    private fetchSettings;
+    /**
+     * Sets settings for the plugin.
+     * Automatically saves as guild settings if guild doesn't allow user settings,
+     * otherwise saves as user-specific settings.
+     * @param settings - The settings object to save.
+     * @throws {Error} if RLS blocks the operation.
+     */
+    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.
+     * @returns The settings for the plugin.
+     */
+    getSettings<T extends object>(defaultSettings: T): Promise<T>;
+}

package/dist/rimori-client/src/controller/SettingsController.js

@@ -0,0 +1,118 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+export class SettingsController {
+    constructor(supabase, pluginId, guild) {
+        this.supabase = supabase;
+        this.pluginId = pluginId;
+        this.guild = guild;
+    }
+    /**
+     * Fetches settings based on guild configuration.
+     * If guild doesn't allow user settings, fetches guild-level settings.
+     * Otherwise, fetches user-specific settings.
+     * @returns The settings object or null if not found.
+     */
+    fetchSettings() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const isGuildSetting = !this.guild.allowUserPluginSettings;
+            const { data } = yield this.supabase
+                .from('plugin_settings')
+                .select('*')
+                .eq('plugin_id', this.pluginId)
+                .eq('guild_id', this.guild.id)
+                .eq('is_guild_setting', isGuildSetting)
+                .maybeSingle();
+            return (_a = data === null || data === void 0 ? void 0 : data.settings) !== null && _a !== void 0 ? _a : null;
+        });
+    }
+    /**
+     * Sets settings for the plugin.
+     * Automatically saves as guild settings if guild doesn't allow user settings,
+     * otherwise saves as user-specific settings.
+     * @param settings - The settings object to save.
+     * @throws {Error} if RLS blocks the operation.
+     */
+    setSettings(settings) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const isGuildSetting = !this.guild.allowUserPluginSettings;
+            const payload = {
+                plugin_id: this.pluginId,
+                settings,
+                guild_id: this.guild.id,
+                is_guild_setting: isGuildSetting,
+            };
+            if (isGuildSetting) {
+                payload.user_id = null;
+            }
+            // Try UPDATE first (safe with RLS). If nothing updated, INSERT.
+            const updateQuery = this.supabase
+                .from('plugin_settings')
+                .update({ settings })
+                .eq('plugin_id', this.pluginId)
+                .eq('guild_id', this.guild.id)
+                .eq('is_guild_setting', isGuildSetting);
+            const { data: updatedRows, error: updateError } = yield (isGuildSetting
+                ? updateQuery.is('user_id', null).select('id')
+                : updateQuery.select('id'));
+            if (updateError) {
+                if (updateError.code === '42501' || ((_a = updateError.message) === null || _a === void 0 ? void 0 : _a.includes('policy'))) {
+                    throw new Error(`Cannot set ${isGuildSetting ? 'guild' : 'user'} settings: Permission denied.`);
+                }
+                // proceed to try insert in case of other issues
+            }
+            if (updatedRows && updatedRows.length > 0) {
+                return; // updated successfully
+            }
+            // No row updated -> INSERT
+            const { error: insertError } = yield this.supabase.from('plugin_settings').insert(payload);
+            if (insertError) {
+                // In case of race condition (duplicate), try one more UPDATE
+                if (insertError.code === '23505' /* unique_violation */) {
+                    const retry = this.supabase
+                        .from('plugin_settings')
+                        .update({ settings })
+                        .eq('plugin_id', this.pluginId)
+                        .eq('guild_id', this.guild.id)
+                        .eq('is_guild_setting', isGuildSetting);
+                    const { error: retryError } = yield (isGuildSetting ? retry.is('user_id', null) : retry);
+                    if (!retryError)
+                        return;
+                }
+                throw insertError;
+            }
+        });
+    }
+    /**
+     * 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.
+     * @returns The settings for the plugin.
+     */
+    getSettings(defaultSettings) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const storedSettings = (yield this.fetchSettings());
+            if (!storedSettings) {
+                yield this.setSettings(defaultSettings);
+                return defaultSettings;
+            }
+            // Handle settings migration
+            const storedKeys = Object.keys(storedSettings);
+            const defaultKeys = Object.keys(defaultSettings);
+            if (storedKeys.length !== defaultKeys.length) {
+                const validStoredSettings = Object.fromEntries(Object.entries(storedSettings).filter(([key]) => defaultKeys.includes(key)));
+                const mergedSettings = Object.assign(Object.assign({}, defaultSettings), validStoredSettings);
+                yield this.setSettings(mergedSettings);
+                return mergedSettings;
+            }
+            return storedSettings;
+        });
+    }
+}

package/dist/rimori-client/src/controller/SharedContentController.d.ts

@@ -0,0 +1,106 @@
+import { SupabaseClient } from '@supabase/supabase-js';
+import { RimoriClient } from '../plugin/RimoriClient';
+import { ObjectRequest } from './ObjectController';
+export interface SharedContentObjectRequest extends ObjectRequest {
+    fixedProperties?: Record<string, string | number | boolean>;
+}
+export type SharedContentFilter = Record<string, string | number | boolean>;
+export declare class SharedContentController {
+    private supabase;
+    private rimoriClient;
+    constructor(supabase: SupabaseClient, rimoriClient: RimoriClient);
+    /**
+     * Fetch new shared content for a given content type.
+     * @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 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, 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.
+     * @param filter - Optional filter to apply to the query.
+     * @param limit - Optional limit for the number of results.
+     * @returns Array of shared content matching the criteria.
+     */
+    getSharedContentList<T>(contentType: string, filter?: SharedContentFilter, limit?: number): Promise<SharedContent<T>[]>;
+    /**
+     * Insert new shared content into the database.
+     * @param param
+     * @param param.contentType - The type of content to insert.
+     * @param param.title - The title of the content.
+     * @param param.keywords - Keywords associated with the content.
+     * @param param.data - The content data to store.
+     * @param param.privateTopic - Optional flag to indicate if the topic should be private.
+     * @returns The inserted shared content.
+     * @throws {Error} if insertion fails.
+     */
+    createSharedContent<T>({ contentType, title, keywords, data, privateTopic, }: Omit<SharedContent<T>, 'id'>): Promise<SharedContent<T>>;
+    /**
+     * Update existing shared content in the database.
+     * @param id - The ID of the content to update.
+     * @param updates - The updates to apply to the shared content.
+     * @returns The updated shared content.
+     * @throws {Error} if update fails.
+     */
+    updateSharedContent<T>(id: string, updates: Partial<SharedContent<T>>): Promise<SharedContent<T>>;
+    /**
+     * Soft delete shared content by setting the deleted_at timestamp.
+     * @param id - The ID of the content to delete.
+     * @returns The deleted shared content record.
+     * @throws {Error} if deletion fails or content not found.
+     */
+    removeSharedContent(id: string): Promise<SharedContent<any>>;
+}
+/**
+ * Interface representing shared content in the system.
+ * @template T The type of data stored in the content
+ */
+export interface SharedContent<T> {
+    /** The id of the content */
+    id: string;
+    /** The type/category of the content (e.g. 'grammar_exercises', 'flashcards', etc.) */
+    contentType: string;
+    /** The human readable title of the content */
+    title: string;
+    /** Array of keywords/tags associated with the content for search and categorization */
+    keywords: string[];
+    /** The actual content data of type T */
+    data: T;
+    /** Whether this content should only be visible to the creator. Defaults to false if not specified */
+    privateTopic?: boolean;
+}