@rimori/client 1.1.10 → 1.2.0

package/src/core/controller/AIController.ts

@@ -0,0 +1,122 @@
+import { Tool } from "../../fromRimori/PluginTypes";
+
+export interface ToolInvocation {
+  toolCallId: string;
+  toolName: string;
+  args: Record<string, string>;
+}
+
+export interface Message {
+  id?: string;
+  role: "user" | "assistant" | "system"
+  content: string;
+  toolCalls?: ToolInvocation[];
+}
+
+export async function generateText(backendUrl: string, messages: Message[], tools: Tool[], token: string) {
+  const response = await fetch(`${backendUrl}/ai/llm`, {
+    method: 'POST',
+    body: JSON.stringify({ messages, tools }),
+    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 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];
+
+  while (true) {
+    const messagesForApi = currentMessages.map(({ id, ...rest }) => rest);
+
+    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' }
+    });
+
+    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: { toolCallId: string, toolName: string, args: any }[] = [];
+    let finishReason = "";
+
+    while (!done) {
+      const { value, done: readerDone } = await 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;
+          } else if (command === '9') {
+            const toolInvocation = JSON.parse(line.substring(2));
+            toolInvocations.push(toolInvocation);
+          }
+        }
+      }
+
+      if (readerDone) {
+        done = true;
+      }
+    }
+
+    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: Message[] = [];
+    for (const toolInvocation of toolInvocations) {
+      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",
+            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}`,
+          });
+        }
+      }
+    }
+    currentMessages.push(...toolResults);
+  }
+}

package/src/core/controller/ObjectController.ts

@@ -0,0 +1,115 @@
+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)
+
+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 async function generateObject(supabaseUrl: string, request: ObjectRequest, token: string) {
+  return await fetch(`${supabaseUrl}/functions/v1/llm-object`, {
+    method: 'POST',
+    body: JSON.stringify({
+      stream: false,
+      tool: request.tool,
+      behaviour: request.behaviour,
+      instructions: request.instructions,
+    }),
+    headers: { 'Authorization': `Bearer ${token}` }
+  }).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(supabaseUrl: string, request: ObjectRequest, onResponse: OnLLMResponse, token: string) {
+  const messageId = Math.random().toString(36).substring(3);
+  const response = await fetch(`${supabaseUrl}/functions/v1/llm-object`, {
+    method: 'POST',
+    body: JSON.stringify({
+      stream: true,
+      tools: request.tool,
+      systemInstructions: request.behaviour,
+      secondaryInstructions: request.instructions,
+    }),
+    headers: { 'Authorization': `Bearer ${token}` }
+  });
+
+  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: any[] = [];
+  while (!done) {
+    const { value } = await 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'), 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'), true, toolInvocations);
+}

package/src/{controller → core/controller}/SettingsController.ts

@@ -1,6 +1,15 @@
 import { SupabaseClient } from "@supabase/supabase-js";
-import { LanguageLevel } from "../utils/difficultyConverter";
-import { Language } from "../utils/Language";
+import { LanguageLevel } from "../../utils/difficultyConverter";
+import { Language } from "../../utils/Language";
+
+export interface Buddy {
+  id: string;
+  name: string;
+  description: string;
+  avatarUrl: string;
+  voiceId: string;
+  aiPersonality: string;
+}
 
 export interface UserInfo {
   skill_level_reading: LanguageLevel;
@@ -11,13 +20,14 @@ export interface UserInfo {
   skill_level_understanding: LanguageLevel;
   goal_longterm: string;
   goal_weekly: string;
-  study_buddy: string;
+  study_buddy: Buddy;
   story_genre: string;
   study_duration: number;
   mother_tongue: Language;
   motivation_type: string;
   onboarding_completed: boolean;
   context_menu_on_select: boolean;
+  user_name?: string;
 }
 
 export class SettingsController {
@@ -43,32 +53,6 @@ export class SettingsController {
     await this.supabase.from("plugin_settings").upsert({ plugin_id: this.pluginId, settings });
   }
 
-  public async getUserInfo(): Promise<UserInfo> {
-    const { data } = await this.supabase.from("profiles").select("*");
-
-    if (!data || data.length === 0) {
-      return {
-        mother_tongue: "en",
-        skill_level_listening: "Pre-A1",
-        skill_level_reading: "Pre-A1",
-        skill_level_speaking: "Pre-A1",
-        skill_level_writing: "Pre-A1",
-        skill_level_understanding: "Pre-A1",
-        skill_level_grammar: "Pre-A1",
-        goal_longterm: "",
-        goal_weekly: "",
-        study_buddy: "clarence",
-        story_genre: "adventure",
-        study_duration: 30,
-        motivation_type: "self-motivated",
-        onboarding_completed: false,
-        context_menu_on_select: false,
-      }
-    }
-
-    return data[0].settings;
-  }
-
   /**
    * 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 → core/controller}/SharedContentController.ts

@@ -1,5 +1,5 @@
 import { SupabaseClient } from '@supabase/supabase-js';
-import { RimoriClient } from "../plugin/RimoriClient";
+import { RimoriClient } from "../../plugin/RimoriClient";
 import { ObjectRequest } from "./ObjectController";
 
 export interface SharedContentObjectRequest extends ObjectRequest {
@@ -62,16 +62,16 @@ export class SharedContentController {
 
     console.log('fullInstructions:', fullInstructions);
 
-    const instructions = await this.rimoriClient.llm.getObject(fullInstructions);
+    const instructions = await this.rimoriClient.ai.getObject(fullInstructions);
 
     console.log('instructions:', instructions);
 
     const { data: newAssignment, error: insertError } = await this.supabase.from("shared_content").insert({
       private: privateTopic,
       content_type: contentType,
-      topic: instructions.topic,
+      title: instructions.title,
       keywords: instructions.keywords.map(({ text }: { text: string }) => text),
-      data: { ...instructions, topic: undefined, keywords: undefined, ...generatorInstructions.fixedProperties },
+      data: { ...instructions, title: undefined, keywords: undefined, ...generatorInstructions.fixedProperties },
     }).select();
 
     if (insertError) {
@@ -88,7 +88,7 @@ export class SharedContentController {
     generatorInstructions.instructions += `
     The following topics are already taken: ${completedTopics.join(', ')}`;
 
-    generatorInstructions.tool.topic = {
+    generatorInstructions.tool.title = {
       type: "string",
       description: "What the topic is about. Short. ",
     }

package/src/core/core.ts

@@ -0,0 +1,15 @@
+// Core functionality exports
+export * from "../fromRimori/PluginTypes";
+export * from "../plugin/PluginController";
+export * from "../plugin/RimoriClient";
+export * from "../utils/difficultyConverter";
+export * from "../utils/Language";
+export * from "../utils/PluginUtils";
+export * from "../worker/WorkerSetup";
+export { EventBusMessage } from "../fromRimori/EventBus";
+export { Buddy, UserInfo } from "./controller/SettingsController";
+export { SharedContent } from "./controller/SharedContentController";
+export { Message, OnLLMResponse, ToolInvocation } from "./controller/AIController";
+export { MacroAccomplishmentPayload, MicroAccomplishmentPayload } from "../plugin/AccomplishmentHandler";
+export { Tool } from "../fromRimori/PluginTypes";
+

package/src/{plugin/fromRimori → fromRimori}/EventBus.ts

@@ -130,7 +130,7 @@ export class EventBusHandler {
    * @param topics - The topic of the event.
    * @param handler - The handler to be called when the event is emitted.
    * @param ignoreSender - The senders to ignore.
-   * @returns The ids of the listeners.
+   * @returns An EventListener object containing an off() method to unsubscribe the listeners.
    */
   public on<T = EventPayload>(topics: string | string[], handler: EventHandler<T>, ignoreSender: string[] = []): EventListener {
     const ids = this.toArray(topics).map(topic => {
@@ -163,17 +163,35 @@ export class EventBusHandler {
    * @param sender - The sender of the event.
    * @param topic - The topic of the event.
    * @param handler - The handler to be called when the event is received. The handler returns the data to be emitted. Can be a static object or a function.
-   * @returns The ids of the listeners.
+   * @returns An EventListener object containing an off() method to unsubscribe the listeners.
    */
-  public respond(sender: string, topic: string, handler: EventPayload | ((data: EventBusMessage) => EventPayload | Promise<EventPayload>)): EventListener {
-    const listener = this.on(topic, async (data: EventBusMessage) => {
-      const response = typeof handler === "function" ? await handler(data) : handler;
-      this.emit(sender, topic, response, data.eventId);
-    }, [sender]);
-
-    this.logIfDebug(`Added respond listener ` + sender + " to topic " + topic, { listener, sender });
+  public respond(sender: string, topic: string | string[], handler: EventPayload | ((data: EventBusMessage) => EventPayload | Promise<EventPayload>)): EventListener {
+    const topics = Array.isArray(topic) ? topic : [topic];
+    const listeners = topics.map(topic => {
+      const blackListedEventIds: number[] = [];
+      //To allow event communication inside the same plugin the sender needs to be ignored but the events still need to be checked for the same event just reaching the subscriber to prevent infinite loops
+      const finalIgnoreSender = !topic.startsWith("self.") ? [sender] : [];
+
+      const listener = this.on(topic, async (data: EventBusMessage) => {
+        if (blackListedEventIds.includes(data.eventId)) {
+          // console.log("BLACKLISTED EVENT ID", data.eventId);
+          return;
+        }
+        blackListedEventIds.push(data.eventId);
+        if (blackListedEventIds.length > 20) {
+          blackListedEventIds.shift();
+        }
+        const response = typeof handler === "function" ? await handler(data) : handler;
+        this.emit(sender, topic, response, data.eventId);
+      }, finalIgnoreSender);
+
+      this.logIfDebug(`Added respond listener ` + sender + " to topic " + topic, { listener, sender });
+      return {
+        off: () => listener.off()
+      };
+    });
     return {
-      off: () => listener.off()
+      off: () => listeners.forEach(listener => listener.off())
     };
   }
 

package/src/fromRimori/PluginTypes.ts

@@ -0,0 +1,203 @@
+// whole configuration of a plugin (from the database)
+export type Plugin = Omit<RimoriPluginConfig, 'context_menu_actions'> & {
+  version: string;
+  endpoint: string;
+  assetEndpoint: string;
+  context_menu_actions: MenuEntry[];
+  release_channel: "alpha" | "beta" | "stable";
+}
+
+// browsable page of a plugin
+export interface PluginPage {
+  id: string;
+  name: string;
+  url: string;
+  // Whether the page should be shown in the navbar
+  show: boolean;
+  description: string;
+  root: "vocabulary" | "grammar" | "reading" | "listening" | "watching" | "writing" | "speaking" | "other" | "community";
+  // The actions that can be triggered in the plugin
+  // The key is the action key. The other entries are additional properties needed when triggering the action
+  action?: {
+    key: string;
+    parameters: ObjectTool;
+  }
+}
+
+// a sidebar page of a plugin
+export interface SidebarPage {
+  // identifier of the page. Used to know which page to trigger when clicking on the sidebar
+  id: string;
+  // name of the page. Shown in the settings
+  name: string;
+  // description of the page. Shown in the settings
+  description: string;
+  // relative or absolute URL or path to the plugin's page
+  url: string;
+  // relative or absolute URL or path to the plugin's icon image
+  icon: string;
+}
+
+// context menu entry being configured in the plugin configuration
+export interface MenuEntry {
+  // id of the plugin that the menu entry belongs to
+  plugin_id: string;
+  // identifier of the menu entry action. Used to know which entry to trigger when clicking on the context menu
+  action_key: string;
+  // text of the menu entry. Shown in the context menu
+  text: string;
+  // icon of the menu entry. Shown in the context menu
+  icon?: React.ReactNode;
+}
+
+// an action from the main panel that can be triggered and performs an action in the main panel
+export type MainPanelAction = {
+  plugin_id: string;
+  action_key: string;
+} & Record<string, string>;
+
+// an action from the context menu that can be triggered and performs an action in the sidebar plugin
+export interface ContextMenuAction {
+  // selected text when clicking on the context menu
+  text: string;
+  // id of the plugin that the action belongs to
+  plugin_id: string;
+  // key of the action. Used to know which action to trigger when clicking on the context menu
+  action_key: string
+}
+
+/**
+ * Rimori plugin structure representing the complete configuration
+ * of a Rimori plugin with all metadata and configuration options.
+ */
+export interface RimoriPluginConfig {
+  id: string;
+  /**
+   * Basic information about the plugin including branding and core details.
+   */
+  info: {
+    /** The display name of the plugin shown to users */
+    title: string;
+    /** Detailed description introducing the plugin */
+    description: string;
+    /** relative or absolute URL or path to the plugin's logo/icon image */
+    logo: string;
+    /** Optional website URL for the plugin's homepage or link to plugins owner for contributions */
+    website?: string;
+  }
+  /**
+   * Configuration for different types of pages.
+   */
+  pages: {
+    /** Optional external URL where the plugin is hosted instead of the default CDN */
+    external_hosted_url?: string;
+    /** Array of main plugin pages that appear in the application's main navigation (can be disabled using the 'show' flag) */
+    main: PluginPage[];
+    /** Array of sidebar pages that appear in the sidebar for quick access (can be disabled using the 'show' flag) */
+    sidebar: SidebarPage[];
+    /** Optional path to the plugin's settings/configuration page */
+    settings?: string;
+    /** Optional array of event topics the plugin pages can listen to for cross-plugin communication */
+    topics?: string[];
+  }
+  /**
+   * Context menu actions that the plugin registers to appear in right-click menus throughout the application.
+   */
+  context_menu_actions: Omit<MenuEntry, "plugin_id">[];
+  /**
+   * Documentation paths for different types of plugin documentation.
+   */
+  documentation: {
+    /** Path to the general overview documentation. It's shown upon installation of the plugin. */
+    overview_path: string;
+    /** Path to user-facing documentation and guides */
+    user_path: string;
+    /** Path to developer documentation for plugin development */
+    developer_path: string;
+  }
+  /**
+   * Configuration for the plugin's web worker if it uses background processing or exposes actions to other plugins.
+   */
+  worker?: {
+    /** Relative path to the web worker JavaScript file. Mostly it's 'web-worker.js' which is located in the public folder. */
+    url: string;
+    /** Optional array of event topics the worker should listen to in addition to events having the pluginId in the topic. Can be a wildcard. Example: 'global.topic.*' or 'pluginId.*' */
+    topics?: string[];
+  };
+}
+
+// copied from llm edge function
+
+export interface Tool {
+  name: string;
+  description: string;
+  parameters: {
+    name: string;
+    description: string;
+    type: "string" | "number" | "boolean";
+  }[];
+  execute?: (args: Record<string, any>) => Promise<unknown> | unknown | void;
+}
+
+/**
+ * The tool definition structure is used for LLM function calling and plugin action parameters.
+ * It defines the schema for tools that can be used by Language Learning Models (LLMs)
+ * and plugin actions.
+ * 
+ * @example
+ * ```typescript
+ * const flashcardTool: Tool = {
+ *   total_amount: {
+ *     type: 'string',
+ *     enum: ['default', '10', '20', '50'],
+ *     description: 'Number of flashcards to practice'
+ *   },
+ *   deck: {
+ *     type: 'string', 
+ *     enum: ['latest', 'random', 'oldest', 'mix', 'best_known'],
+ *     description: 'Type of deck to practice'
+ *   }
+ * };
+ * ```
+ * 
+ */
+export type ObjectTool = {
+  [key: string]: ToolParameter;
+};
+
+/**
+ * Parameter definition for LLM tools and plugin actions.
+ * Defines the structure, validation rules, and metadata for individual tool parameters.
+ * Used to create type-safe interfaces between LLMs, plugins, and the Rimori platform.
+ */
+interface ToolParameter {
+  /** The data type of the parameter - can be primitive, nested object, or array */
+  type: ToolParameterType;
+  /** Human-readable description of the parameter's purpose and usage */
+  description: string;
+  /** Optional array of allowed values for enumerated parameters */
+  enum?: string[];
+  /** Whether the parameter is optional */
+  optional?: boolean;
+}
+
+/**
+ * Union type defining all possible parameter types for LLM tools.
+ * Supports primitive types, nested objects for complex data structures,
+ * and arrays of objects for collections. The tuple notation [{}] indicates
+ * arrays of objects with a specific structure.
+ * 
+ * @example Primitive: 'string' | 'number' | 'boolean'
+ * @example Nested object: { name: { type: 'string' }, age: { type: 'number' } }
+ * @example Array of objects: [{ id: { type: 'string' }, value: { type: 'number' } }]
+ */
+type ToolParameterType =
+  | PrimitiveType
+  | { [key: string]: ToolParameter }  // for nested objects
+  | [{ [key: string]: ToolParameter }];  // for arrays of objects (notice the tuple type)
+
+/**
+ * Primitive data types supported by the LLM tool system.
+ * These align with JSON schema primitive types and TypeScript basic types.
+ */
+type PrimitiveType = 'string' | 'number' | 'boolean';

package/src/hooks/UseChatHook.ts

@@ -1,14 +1,15 @@
 import React from "react";
-import { Message, Tool, ToolInvocation } from "../controller/AIController";
+import { Tool } from "../fromRimori/PluginTypes";
 import { usePlugin } from "../providers/PluginProvider";
+import { Message, ToolInvocation } from "../core/controller/AIController";
 
 export function useChat(tools?: Tool[]) {
   const [messages, setMessages] = React.useState<Message[]>([]);
   const [isLoading, setIsLoading] = React.useState(false);
-  const { llm } = usePlugin();
+  const { ai } = usePlugin();
 
   const append = (appendMessages: Message[]) => {
-    llm.getSteamedText([...messages, ...appendMessages], (id, message, finished: boolean, toolInvocations?: ToolInvocation[]) => {
+    ai.getSteamedText([...messages, ...appendMessages], (id, message, finished: boolean, toolInvocations?: ToolInvocation[]) => {
       const lastMessage = messages[messages.length - 1];
       setIsLoading(!finished);
 
@@ -16,7 +17,7 @@ export function useChat(tools?: Tool[]) {
         lastMessage.content = message;
         setMessages([...messages, lastMessage]);
       } else {
-        setMessages([...messages, ...appendMessages, { id, role: 'assistant', content: message, toolInvocations }]);
+        setMessages([...messages, ...appendMessages, { id, role: 'assistant', content: message, toolCalls: toolInvocations }]);
       }
     }, tools);
   };

package/src/index.ts

@@ -1,9 +1,11 @@
 // Re-export everything
-export * from './core';
 export * from './components';
 export * from "./hooks/UseChatHook";
-export * from "./plugin/RimoriClient";
+export * from "./plugin/PluginController";
 export * from "./providers/PluginProvider";
+export * from "./cli/types/DatabaseTypes";
 export * from "./utils/difficultyConverter";
 export * from "./utils/PluginUtils";
-export * from "./plugin/PluginController";
+export * from "./utils/Language";
+export * from "./fromRimori/PluginTypes";
+export { FirstMessages } from "./components/ai/utils";

package/src/plugin/AccomplishmentHandler.ts

@@ -1,4 +1,4 @@
-import { EventBus, EventBusMessage } from "./fromRimori/EventBus";
+import { EventBus, EventBusMessage } from "../fromRimori/EventBus";
 
 export type AccomplishmentMessage = EventBusMessage<MicroAccomplishmentPayload>;