@rimori/client 1.1.9 → 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,17 +1,7 @@
 import { SupabaseClient } from '@supabase/supabase-js';
-import { RimoriClient } from "../plugin/RimoriClient";
+import { RimoriClient } from "../../plugin/RimoriClient";
 import { ObjectRequest } from "./ObjectController";
 
-export interface BasicAssignment<T> {
-  id: string;
-  createdAt: Date;
-  topic: string;
-  createdBy: string;
-  verified: boolean;
-  keywords: any;
-  data: T;
-}
-
 export interface SharedContentObjectRequest extends ObjectRequest {
   fixedProperties?: Record<string, string | number | boolean>
 }
@@ -41,7 +31,7 @@ export class SharedContentController {
     //this filter is there if the content should be filtered additionally by a column and value
     filter?: SharedContentFilter,
     privateTopic?: boolean,
-  ): Promise<BasicAssignment<T>> {
+  ): Promise<SharedContent<T>> {
     const query = this.supabase.from("shared_content")
       .select("*, scc:shared_content_completed(id)")
       .eq('content_type', contentType)
@@ -72,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) {
@@ -98,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. ",
     }
@@ -111,7 +101,7 @@ export class SharedContentController {
 
   private async getCompletedTopics(contentType: string, filter?: SharedContentFilter): Promise<string[]> {
     const query = this.supabase.from("shared_content")
-      .select("topic, keywords, scc:shared_content_completed(id)")
+      .select("title, keywords, scc:shared_content_completed(id)")
       .eq('content_type', contentType)
       .not('scc.id', 'is', null)
       .is('deleted_at', null)
@@ -126,10 +116,10 @@ export class SharedContentController {
       console.error('error fetching old assignments:', error);
       return [];
     }
-    return oldAssignments.map(({ topic, keywords }) => `${topic}(${keywords.join(',')})`);
+    return oldAssignments.map(({ title, keywords }) => `${title}(${keywords.join(',')})`);
   }
 
-  public async getSharedContent<T>(contentType: string, id: string): Promise<BasicAssignment<T>> {
+  public async getSharedContent<T>(contentType: string, id: string): Promise<SharedContent<T>> {
     const { data, error } = await this.supabase.from("shared_content").select().eq('content_type', contentType).eq('id', id).is('deleted_at', null).single();
     if (error) {
       console.error('error fetching shared content:', error);
@@ -149,7 +139,7 @@ export class SharedContentController {
    * @param limit - Optional limit for the number of results.
    * @returns Array of shared content matching the criteria.
    */
-  public async getSharedContentList<T>(contentType: string, filter?: SharedContentFilter, limit?: number): Promise<BasicAssignment<T>[]> {
+  public async getSharedContentList<T>(contentType: string, filter?: SharedContentFilter, limit?: number): Promise<SharedContent<T>[]> {
     const query = this.supabase.from("shared_content").select("*").eq('content_type', contentType).is('deleted_at', null).limit(limit ?? 30);
 
     if (filter) {
@@ -170,18 +160,18 @@ export class SharedContentController {
    * Insert new shared content into the database.
    * @param param
    * @param param.contentType - The type of content to insert.
-   * @param param.topic - The topic of the content.
+   * @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.
    */
-  public async createSharedContent<T>({ contentType, topic, keywords, data, privateTopic }: Omit<SharedContent<T>, 'id'>): Promise<BasicAssignment<T>> {
+  public async createSharedContent<T>({ contentType, title, keywords, data, privateTopic }: Omit<SharedContent<T>, 'id'>): Promise<SharedContent<T>> {
     const { data: newContent, error } = await this.supabase.from("shared_content").insert({
       private: privateTopic,
       content_type: contentType,
-      topic,
+      title,
       keywords,
       data,
     }).select();
@@ -201,11 +191,11 @@ export class SharedContentController {
    * @returns The updated shared content.
    * @throws {Error} if update fails.
    */
-  public async updateSharedContent<T>(id: string, updates: Partial<SharedContent<T>>): Promise<BasicAssignment<T>> {
+  public async updateSharedContent<T>(id: string, updates: Partial<SharedContent<T>>): Promise<SharedContent<T>> {
     const updateData: any = {};
 
     if (updates.contentType) updateData.content_type = updates.contentType;
-    if (updates.topic) updateData.topic = updates.topic;
+    if (updates.title) updateData.title = updates.title;
     if (updates.keywords) updateData.keywords = updates.keywords;
     if (updates.data) updateData.data = updates.data;
     if (updates.privateTopic !== undefined) updateData.private = updates.privateTopic;
@@ -230,7 +220,7 @@ export class SharedContentController {
    * @returns The deleted shared content record.
    * @throws {Error} if deletion fails or content not found.
    */
-  public async removeSharedContent(id: string): Promise<BasicAssignment<any>> {
+  public async removeSharedContent(id: string): Promise<SharedContent<any>> {
     const { data: deletedContent, error } = await this.supabase
       .from("shared_content")
       .update({ deleted_at: new Date().toISOString() })
@@ -261,8 +251,8 @@ export interface SharedContent<T> {
   /** The type/category of the content (e.g. 'grammar_exercises', 'flashcards', etc.) */
   contentType: string;
 
-  /** The human readable title/topic of the content */
-  topic: string;
+  /** The human readable title of the content */
+  title: string;
 
   /** Array of keywords/tags associated with the content for search and categorization */
   keywords: string[];

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())
     };
   }