@rimori/client 1.3.1 → 1.4.3

package/src/core/controller/AIController.ts

@@ -1,4 +1,4 @@
-import { Tool } from "../../fromRimori/PluginTypes";
+import { Tool } from '../../fromRimori/PluginTypes';
 
 export interface ToolInvocation {
   toolCallId: string;
@@ -8,7 +8,7 @@ export interface ToolInvocation {
 
 export interface Message {
   id?: string;
-  role: "user" | "assistant" | "system"
+  role: 'user' | 'assistant' | 'system';
   content: string;
   toolCalls?: ToolInvocation[];
 }
@@ -17,15 +17,26 @@ export async function generateText(backendUrl: string, messages: Message[], tool
   const response = await fetch(`${backendUrl}/ai/llm`, {
     method: 'POST',
     body: JSON.stringify({ messages, tools }),
-    headers: { 'Authorization': `Bearer ${token}`, 'Content-Type': 'application/json' }
+    headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/json' },
   });
 
   return await response.json();
 }
 
-export type OnLLMResponse = (id: string, response: string, finished: boolean, toolInvocations?: ToolInvocation[]) => void;
+export type OnLLMResponse = (
+  id: string,
+  response: string,
+  finished: boolean,
+  toolInvocations?: ToolInvocation[],
+) => void;
 
-export async function streamChatGPT(backendUrl: string, messages: Message[], tools: Tool[], onResponse: OnLLMResponse, token: string) {
+export async function streamChatGPT(
+  backendUrl: string,
+  messages: Message[],
+  tools: Tool[],
+  onResponse: OnLLMResponse,
+  token: string,
+) {
   const messageId = Math.random().toString(36).substring(3);
   let currentMessages: Message[] = [...messages];
 
@@ -33,7 +44,7 @@ export async function streamChatGPT(backendUrl: string, messages: Message[], too
     messageId,
     messageCount: messages.length,
     toolCount: tools.length,
-    backendUrl
+    backendUrl,
   });
 
   while (true) {
@@ -43,7 +54,7 @@ export async function streamChatGPT(backendUrl: string, messages: Message[], too
       const response = await fetch(`${backendUrl}/ai/llm`, {
         method: 'POST',
         body: JSON.stringify({ messages: messagesForApi, tools, stream: true }),
-        headers: { 'Authorization': `Bearer ${token}`, 'Content-Type': 'application/json' }
+        headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/json' },
       });
 
       if (!response.ok) {
@@ -58,12 +69,12 @@ export async function streamChatGPT(backendUrl: string, messages: Message[], too
       const reader = response.body.getReader();
       const decoder = new TextDecoder('utf-8');
 
-      let content = "";
+      let content = '';
       let done = false;
-      let toolInvocations: { toolCallId: string, toolName: string, args: any }[] = [];
-      let currentTextId = "";
+      let toolInvocations: { toolCallId: string; toolName: string; args: any }[] = [];
+      let currentTextId = '';
       let isToolCallMode = false;
-      let buffer = ""; // Buffer for incomplete chunks
+      let buffer = ''; // Buffer for incomplete chunks
 
       while (!done) {
         const { value, done: readerDone } = await reader.read();
@@ -71,22 +82,22 @@ export async function streamChatGPT(backendUrl: string, messages: Message[], too
         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() || "";
+            buffer = lines.pop() || '';
           }
 
           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;
@@ -95,39 +106,39 @@ export async function streamChatGPT(backendUrl: string, messages: Message[], too
 
               try {
                 const data = JSON.parse(dataStr);
-                
+
                 // Log the first message to understand the format
                 if (!content && !isToolCallMode) {
-                  console.log('First stream message received:', data);
+                  // console.log('First stream message received:', data);
                 }
-                
+
                 switch (data.type) {
                   case 'start':
                     // Stream started, no action needed
-                    console.log('Stream started');
+                    // console.log('Stream started');
                     break;
-                    
+
                   case 'start-step':
                     // Step started, no action needed
-                    console.log('Step started');
+                    // 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) {
@@ -135,73 +146,75 @@ export async function streamChatGPT(backendUrl: string, messages: Message[], too
                       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');
+                    // console.log('Step finished');
                     break;
-                    
+
                   case 'finish':
                     // Stream finished
-                    console.log('Stream finished');
+                    // console.log('Stream finished');
                     done = true;
                     break;
-                    
+
                   // Additional message types that might be present in the AI library
                   case 'tool-call':
+                  case 'tool-input-available': //for now input calls should be handled the same way as tool calls
                     // Tool call initiated
                     console.log('Tool call initiated:', data);
                     isToolCallMode = true;
-                    if (data.toolCallId && data.toolName && data.args) {
+                    if (data.toolCallId && data.toolName && (data.args || data.input)) {
                       toolInvocations.push({
                         toolCallId: data.toolCallId,
                         toolName: data.toolName,
-                        args: data.args
+                        args: data.args || data.input,
                       });
                     }
                     break;
-                    
+
+                  case 'tool-input-delta': //for now input calls should be handled the same way as tool calls
                   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);
@@ -223,38 +236,38 @@ export async function streamChatGPT(backendUrl: string, messages: Message[], too
       if (content || toolInvocations.length > 0) {
         currentMessages.push({
           id: messageId,
-          role: "assistant",
+          role: 'assistant',
           content: content,
-          toolCalls: toolInvocations.length > 0 ? toolInvocations: undefined,
+          toolCalls: toolInvocations.length > 0 ? toolInvocations : undefined,
         });
       }
 
       // Handle tool call scenario if tools were provided
       if (tools.length > 0 && toolInvocations.length > 0) {
         console.log('Tool calls detected, executing tools...');
-        
+
         const toolResults: Message[] = [];
         for (const toolInvocation of toolInvocations) {
-          const tool = tools.find(t => t.name === toolInvocation.toolName);
+          const tool = tools.find((t) => t.name === toolInvocation.toolName);
           if (tool && tool.execute) {
             try {
               const result = await tool.execute(toolInvocation.args);
               toolResults.push({
                 id: Math.random().toString(36).substring(3),
-                role: "user",
+                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",
+                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
@@ -273,7 +286,6 @@ export async function streamChatGPT(backendUrl: string, messages: Message[], too
 
       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, []);

package/src/core/controller/ExerciseController.ts

@@ -0,0 +1,98 @@
+import { SupabaseClient } from '@supabase/supabase-js';
+import { PluginController } from '../../plugin/PluginController';
+
+export type TriggerAction = { action_key: string } & Record<string, string | number | boolean>;
+
+export interface CreateExerciseParams {
+  plugin_id: string;
+  start_date: string;
+  end_date: string;
+  trigger_action: TriggerAction;
+  name: string;
+  description: string;
+  estimated_duration: number;
+}
+
+export interface Exercise {
+  id: string;
+  plugin_id: string;
+  start_date: string;
+  end_date: string;
+  trigger_action: TriggerAction;
+  name: string;
+  description: string;
+  estimated_duration: number;
+  created_at?: string;
+  updated_at?: string;
+}
+
+export class ExerciseController {
+  private supabase: SupabaseClient;
+  private pluginController: PluginController;
+
+  constructor(supabase: SupabaseClient, pluginController: PluginController) {
+    this.supabase = supabase;
+    this.pluginController = pluginController;
+  }
+
+  /**
+   * Fetches weekly exercises from the weekly_exercises view.
+   * Shows exercises for the current week that haven't expired.
+   * @returns Array of exercise objects.
+   */
+  public async viewWeeklyExercises(): Promise<Exercise[]> {
+    const { data, error } = await this.supabase.from('weekly_exercises').select('*');
+
+    if (error) {
+      throw new Error(`Failed to fetch weekly exercises: ${error.message}`);
+    }
+
+    return data || [];
+  }
+
+  /**
+   * Creates a new exercise via the backend API.
+   * @param params Exercise creation parameters.
+   * @returns Created exercise object.
+   */
+  public async addExercise(params: CreateExerciseParams): Promise<Exercise> {
+    const token = await this.pluginController.getToken();
+    const response = await fetch(`${this.pluginController.getBackendUrl()}/exercises`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        Authorization: `Bearer ${token}`,
+      },
+      body: JSON.stringify(params),
+    });
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`Failed to create exercise: ${errorText}`);
+    }
+
+    return await response.json();
+  }
+
+  /**
+   * Deletes an exercise via the backend API.
+   * @param id The exercise ID to delete.
+   * @returns Success status.
+   */
+  public async deleteExercise(id: string): Promise<{ success: boolean; message: string }> {
+    const token = await this.pluginController.getToken();
+    const response = await fetch(`${this.pluginController.getBackendUrl()}/exercises/${id}`, {
+      method: 'DELETE',
+      headers: {
+        Authorization: `Bearer ${token}`,
+      },
+    });
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`Failed to delete exercise: ${errorText}`);
+    }
+
+    return await response.json();
+  }
+}

package/src/core/controller/ObjectController.ts

@@ -3,8 +3,8 @@ type PrimitiveType = 'string' | 'number' | 'boolean';
 // This is the type that can appear in the `type` property
 type ObjectToolParameterType =
   | PrimitiveType
-  | { [key: string]: ObjectToolParameter }  // for nested objects
-  | [{ [key: string]: ObjectToolParameter }];  // for arrays of objects (notice the tuple type)
+  | { [key: string]: ObjectToolParameter } // for nested objects
+  | [{ [key: string]: ObjectToolParameter }]; // for arrays of objects (notice the tuple type)
 
 interface ObjectToolParameter {
   type: ObjectToolParameterType;
@@ -15,10 +15,10 @@ interface ObjectToolParameter {
 
 /**
  * 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;
@@ -50,14 +50,19 @@ export async function generateObject(backendUrl: string, request: ObjectRequest,
       behaviour: request.behaviour,
       instructions: request.instructions,
     }),
-    headers: { 'Authorization': `Bearer ${token}`, 'Content-Type': 'application/json' }
-  }).then(response => response.json());
+    headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/json' },
+  }).then((response) => response.json());
 }
 
 // TODO adjust stream to work with object
 export type OnLLMResponse = (id: string, response: string, finished: boolean, toolInvocations?: any[]) => void;
 
-export async function streamObject(backendUrl: string, request: ObjectRequest, onResponse: OnLLMResponse, token: string) {
+export async function streamObject(
+  backendUrl: string,
+  request: ObjectRequest,
+  onResponse: OnLLMResponse,
+  token: string,
+) {
   const messageId = Math.random().toString(36).substring(3);
   const response = await fetch(`${backendUrl}/ai/llm-object`, {
     method: 'POST',
@@ -67,7 +72,7 @@ export async function streamObject(backendUrl: string, request: ObjectRequest, o
       systemInstructions: request.behaviour,
       secondaryInstructions: request.instructions,
     }),
-    headers: { 'Authorization': `Bearer ${token}`, 'Content-Type': 'application/json' }
+    headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/json' },
   });
 
   if (!response.body) {
@@ -78,7 +83,7 @@ export async function streamObject(backendUrl: string, request: ObjectRequest, o
   const reader = response.body.getReader();
   const decoder = new TextDecoder('utf-8');
 
-  let content = "";
+  let content = '';
   let done = false;
   let toolInvocations: any[] = [];
   while (!done) {
@@ -86,7 +91,7 @@ export async function streamObject(backendUrl: string, request: ObjectRequest, o
 
     if (value) {
       const chunk = decoder.decode(value, { stream: true });
-      const lines = chunk.split('\n').filter(line => line.trim() !== '');
+      const lines = chunk.split('\n').filter((line) => line.trim() !== '');
 
       for (const line of lines) {
         const data = line.substring(3, line.length - 1);

package/src/core/controller/SettingsController.ts

@@ -1,6 +1,7 @@
-import { SupabaseClient } from "@supabase/supabase-js";
-import { LanguageLevel } from "../../utils/difficultyConverter";
-import { Language } from "../../utils/Language";
+import { SupabaseClient } from '@supabase/supabase-js';
+import { LanguageLevel } from '../../utils/difficultyConverter';
+import { Language } from '../../utils/Language';
+import { Guild } from '../core';
 
 export interface Buddy {
   id: string;
@@ -37,45 +38,117 @@ export interface UserInfo {
   context_menu_on_select: boolean;
   user_name?: string;
   /**
-   * ISO 3166-1 alpha-2 country code of user's location (exposed to plugins)
+   * ISO 3166-1 alpha-2 country code of user's target location (exposed to plugins)
    */
-  location_country: string;
+  target_country: string;
   /**
    * Optional: nearest big city (>100,000) near user's location
    */
-  location_city?: string;
+  target_city?: string;
 }
 
 export class SettingsController {
   private pluginId: string;
   private supabase: SupabaseClient;
+  private guild: Guild;
 
-  constructor(supabase: SupabaseClient, pluginId: string) {
+  constructor(supabase: SupabaseClient, pluginId: string, guild: 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.
+   */
   private async fetchSettings(): Promise<any | null> {
-    const { data } = await this.supabase.from("plugin_settings").select("*").eq("plugin_id", this.pluginId)
+    const isGuildSetting = !this.guild.allowUserPluginSettings;
 
-    if (!data || data.length === 0) {
-      return null;
-    }
+    const { data } = await this.supabase
+      .from('plugin_settings')
+      .select('*')
+      .eq('plugin_id', this.pluginId)
+      .eq('guild_id', this.guild.id)
+      .eq('is_guild_setting', isGuildSetting)
+      .maybeSingle();
 
-    return data[0].settings;
+    return data?.settings ?? 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.
+   */
   public async setSettings(settings: any): Promise<void> {
-    await this.supabase.from("plugin_settings").upsert({ plugin_id: this.pluginId, settings });
+    const isGuildSetting = !this.guild.allowUserPluginSettings;
+
+    const payload: any = {
+      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 } = await (isGuildSetting
+      ? updateQuery.is('user_id', null).select('id')
+      : updateQuery.select('id'));
+
+    if (updateError) {
+      if (updateError.code === '42501' || updateError.message?.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 } = await 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 } = await (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. 
+   * @returns The settings for the plugin.
    */
   public async getSettings<T extends object>(defaultSettings: T): Promise<T> {
-    const storedSettings = await this.fetchSettings() as T | null;
+    const storedSettings = (await this.fetchSettings()) as T | null;
 
     if (!storedSettings) {
       await this.setSettings(defaultSettings);
@@ -88,7 +161,7 @@ export class SettingsController {
 
     if (storedKeys.length !== defaultKeys.length) {
       const validStoredSettings = Object.fromEntries(
-        Object.entries(storedSettings).filter(([key]) => defaultKeys.includes(key))
+        Object.entries(storedSettings).filter(([key]) => defaultKeys.includes(key)),
       );
       const mergedSettings = { ...defaultSettings, ...validStoredSettings } as T;