@rimori/client 1.0.0

package/dist/controller/ObjectController.js

@@ -0,0 +1,77 @@
+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());
+    });
+};
+import { env } from "../utils/constants";
+export function generateObject(request, token) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return yield fetch(`${env.SUPABASE_URL}/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());
+    });
+}
+export function streamObject(request, onResponse, token) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const messageId = Math.random().toString(36).substring(3);
+        const response = yield fetch(`${env.SUPABASE_URL}/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 = [];
+        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'), 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/dist/controller/SettingsController.d.ts

@@ -0,0 +1,24 @@
+import { SupabaseClient } from "@supabase/supabase-js";
+import { LanguageLevel } from "../utils/difficultyConverter";
+export interface UserSettings {
+    motherTongue: string;
+    languageLevel: LanguageLevel;
+}
+export interface SystemSettings {
+}
+export declare class SettingsController {
+    private pluginId;
+    private supabase;
+    constructor(supabase: SupabaseClient, pluginId: string);
+    private getSettingsType;
+    private fetchSettings;
+    private saveSettings;
+    /**
+     * 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.
+     * @param genericSettings The type of settings to get.
+     * @returns The settings for the plugin.
+     */
+    getSettings<T extends object>(defaultSettings: T, genericSettings?: "user" | "system"): Promise<T>;
+    setSettings(settings: any, genericSettings?: "user" | "system"): Promise<void>;
+}

package/dist/controller/SettingsController.js

@@ -0,0 +1,72 @@
+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) {
+        this.supabase = supabase;
+        this.pluginId = pluginId;
+    }
+    getSettingsType(genericSettings) {
+        return genericSettings || "plugin";
+    }
+    fetchSettings(type) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const pluginId = type === "plugin" ? this.pluginId : type;
+            const { data } = yield this.supabase.from("plugin_settings").select("*").eq("plugin_id", pluginId);
+            if (!data || data.length === 0) {
+                return null;
+            }
+            return data[0].settings;
+        });
+    }
+    saveSettings(settings, type) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (type !== "plugin") {
+                throw new Error(`Cannot modify ${type} settings`);
+            }
+            yield this.supabase.from("plugin_settings").upsert({ plugin_id: this.pluginId, 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.
+     * @param genericSettings The type of settings to get.
+     * @returns The settings for the plugin.
+     */
+    getSettings(defaultSettings, genericSettings) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const type = this.getSettingsType(genericSettings);
+            const storedSettings = yield this.fetchSettings(type);
+            if (!storedSettings) {
+                if (type === "plugin") {
+                    yield this.saveSettings(defaultSettings, type);
+                }
+                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);
+                if (type === "plugin") {
+                    yield this.saveSettings(mergedSettings, type);
+                }
+                return mergedSettings;
+            }
+            return storedSettings;
+        });
+    }
+    setSettings(settings, genericSettings) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const type = this.getSettingsType(genericSettings);
+            yield this.saveSettings(settings, type);
+        });
+    }
+}

package/dist/controller/SharedContentController.d.ts

@@ -0,0 +1,22 @@
+import { ObjectRequest } from "./ObjectController";
+import { RimoriClient } from "../plugin/RimoriClient";
+export interface BasicAssignment {
+    id: string;
+    createdAt: Date;
+    topic: string;
+    createdBy: string;
+    verified: boolean;
+    keywords: any;
+}
+export declare class SharedContentController {
+    private rimoriClient;
+    constructor(rimoriClient: RimoriClient);
+    fetchNewSharedContent<T, R = T & BasicAssignment>(type: string, generatorInstructions: (reservedTopics: string[]) => Promise<ObjectRequest> | ObjectRequest, filter?: {
+        column: string;
+        value: string | number | boolean;
+    }): Promise<R[]>;
+    private getReservedTopics;
+    private purifyStringArray;
+    getSharedContent<T extends BasicAssignment>(type: string, id: string): Promise<T>;
+    completeSharedContent(type: string, assignmentId: string): Promise<void>;
+}

package/dist/controller/SharedContentController.js

@@ -0,0 +1,56 @@
+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());
+    });
+};
+import { v4 as uuidv4 } from 'uuid';
+export class SharedContentController {
+    constructor(rimoriClient) {
+        this.rimoriClient = rimoriClient;
+    }
+    fetchNewSharedContent(type, generatorInstructions, filter) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const queryParameter = { filter_column: (filter === null || filter === void 0 ? void 0 : filter.column) || null, filter_value: (filter === null || filter === void 0 ? void 0 : filter.value) || null, unread: true };
+            const { data: newAssignments } = yield this.rimoriClient.rpc(type + "_entries", queryParameter);
+            console.log('newAssignments:', newAssignments);
+            if (newAssignments.length > 0) {
+                return newAssignments;
+            }
+            // generate new assignments
+            const { data: oldAssignments } = yield this.rimoriClient.rpc(type + "_entries", Object.assign(Object.assign({}, queryParameter), { unread: false }));
+            console.log('oldAssignments:', oldAssignments);
+            const reservedTopics = this.getReservedTopics(oldAssignments);
+            const request = yield generatorInstructions(reservedTopics);
+            if (!request.tool.keywords || !request.tool.topic) {
+                throw new Error("topic or keywords not found in the request schema");
+            }
+            const instructions = yield this.rimoriClient.generateObject(request);
+            console.log('instructions:', instructions);
+            const preparedData = Object.assign(Object.assign({ id: uuidv4() }, instructions), { keywords: this.purifyStringArray(instructions.keywords) });
+            return yield this.rimoriClient.from(type).insert(preparedData).then(() => [preparedData]);
+        });
+    }
+    getReservedTopics(oldAssignments) {
+        return oldAssignments.map(({ topic, keywords }) => {
+            const keywordTexts = this.purifyStringArray(keywords).join(',');
+            return `${topic}(${keywordTexts})`;
+        });
+    }
+    purifyStringArray(array) {
+        return array.map(({ text }) => text);
+    }
+    getSharedContent(type, id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.rimoriClient.from(type).select().eq('id', id).single();
+        });
+    }
+    completeSharedContent(type, assignmentId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.rimoriClient.from(type + "_result").insert({ assignment_id: assignmentId });
+        });
+    }
+}

package/dist/controller/VoiceController.d.ts

@@ -0,0 +1,10 @@
+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>;
+interface TTSRequest {
+    input: string;
+    voice: string;
+    speed: number;
+    language?: string;
+}
+export {};

package/dist/controller/VoiceController.js

@@ -0,0 +1,28 @@
+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 getSTTResponse(supabase, audio) {
+    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((r) => r.text);
+    });
+}
+export function getTTSResponse(supabaseUrl, request, token) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return yield fetch(`${supabaseUrl}/functions/v1/speech`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${token}`
+            },
+            body: JSON.stringify(request),
+        }).then(r => r.blob());
+    });
+}

package/dist/hooks/UseChatHook.d.ts

@@ -0,0 +1,9 @@
+import React from "react";
+import { Tool, Message } from "../controller/AIController";
+export declare function useChat(tools?: Tool[]): {
+    messages: Message[];
+    append: (appendMessages: Message[]) => void;
+    isLoading: boolean;
+    setMessages: React.Dispatch<React.SetStateAction<Message[]>>;
+    lastMessage: Message | undefined;
+};

package/dist/hooks/UseChatHook.js

@@ -0,0 +1,21 @@
+import React from "react";
+import { usePlugin } from "../providers/PluginProvider";
+export function useChat(tools) {
+    const [messages, setMessages] = React.useState([]);
+    const [isLoading, setIsLoading] = React.useState(false);
+    const { getAIResponseStream } = usePlugin();
+    const append = (appendMessages) => {
+        getAIResponseStream([...messages, ...appendMessages], (id, message, finished, toolInvocations) => {
+            const lastMessage = messages[messages.length - 1];
+            setIsLoading(!finished);
+            if ((lastMessage === null || lastMessage === void 0 ? void 0 : lastMessage.id) === id) {
+                lastMessage.content = message;
+                setMessages([...messages, lastMessage]);
+            }
+            else {
+                setMessages([...messages, ...appendMessages, { id, role: 'assistant', content: message, toolInvocations }]);
+            }
+        }, tools);
+    };
+    return { messages, append, isLoading, setMessages, lastMessage: messages[messages.length - 1] };
+}

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+export * from "./components/MarkdownEditor";
+export * from "./components/CRUDModal";
+export * from "./plugin/ThemeSetter";
+export * from "./components/audio/Playbutton";
+export * from "./providers/EventEmitterContext";
+export * from "./providers/PluginProvider";
+export * from "./providers/EventEmitter";
+export * from "./components/Spinner";
+export * from "./hooks/UseChatHook";
+export * from "./utils/PluginUtils";
+export * from "./plugin/RimoriClient";
+export * from "./controller/AIController";
+export * from "./controller/SharedContentController";
+export * from "./controller/SettingsController";

package/dist/index.js

@@ -0,0 +1,14 @@
+export * from "./components/MarkdownEditor";
+export * from "./components/CRUDModal";
+export * from "./plugin/ThemeSetter";
+export * from "./components/audio/Playbutton";
+export * from "./providers/EventEmitterContext";
+export * from "./providers/PluginProvider";
+export * from "./providers/EventEmitter";
+export * from "./components/Spinner";
+export * from "./hooks/UseChatHook";
+export * from "./utils/PluginUtils";
+export * from "./plugin/RimoriClient";
+export * from "./controller/AIController";
+export * from "./controller/SharedContentController";
+export * from "./controller/SettingsController";

package/dist/plugin/AIController copy.d.ts

@@ -0,0 +1,22 @@
+export interface ToolInvocation {
+    toolName: string;
+    args: Record<string, string>;
+}
+export interface Tool {
+    name: string;
+    description: string;
+    parameters: {
+        name: string;
+        type: "string" | "number" | "boolean";
+        description: string;
+    }[];
+}
+export interface Message {
+    id: string;
+    role: string;
+    content: string;
+    toolInvocations?: ToolInvocation[];
+}
+export declare function generateText(messages: Message[], tools: Tool[], token: string): Promise<any>;
+export type OnLLMResponse = (id: string, response: string, finished: boolean, toolInvocations?: ToolInvocation[]) => void;
+export declare function streamChatGPT(messages: Message[], tools: Tool[], onResponse: OnLLMResponse, token: string): Promise<void>;

package/dist/plugin/AIController copy.js

@@ -0,0 +1,68 @@
+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());
+    });
+};
+import { env } from "../utils/constants";
+export function generateText(messages, tools, token) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const response = yield fetch(`${env.SUPABASE_URL}/functions/v1/llm`, {
+            method: 'POST',
+            body: JSON.stringify({ messages, tools }),
+            headers: { 'Authorization': `Bearer ${token}` }
+        });
+        return yield response.json();
+    });
+}
+export function streamChatGPT(messages, tools, onResponse, token) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const messageId = Math.random().toString(36).substring(3);
+        const response = yield fetch(`${env.SUPABASE_URL}/functions/v1/llm`, {
+            method: 'POST',
+            body: JSON.stringify({ messages, tools, stream: true }),
+            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 = [];
+        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'), 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/dist/plugin/AIController.d.ts

@@ -0,0 +1,22 @@
+export interface ToolInvocation {
+    toolName: string;
+    args: Record<string, string>;
+}
+export interface Tool {
+    name: string;
+    description: string;
+    parameters: {
+        name: string;
+        type: "string" | "number" | "boolean";
+        description: string;
+    }[];
+}
+export interface Message {
+    id: string;
+    role: string;
+    content: string;
+    toolInvocations?: ToolInvocation[];
+}
+export declare function generateText(messages: Message[], tools: Tool[], token: string): Promise<any>;
+export type OnLLMResponse = (id: string, response: string, finished: boolean, toolInvocations?: ToolInvocation[]) => void;
+export declare function streamChatGPT(messages: Message[], tools: Tool[], onResponse: OnLLMResponse, token: string): Promise<void>;

package/dist/plugin/AIController.js

@@ -0,0 +1,68 @@
+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());
+    });
+};
+import { env } from "../utils/constants";
+export function generateText(messages, tools, token) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const response = yield fetch(`${env.SUPABASE_URL}/functions/v1/llm`, {
+            method: 'POST',
+            body: JSON.stringify({ messages, tools }),
+            headers: { 'Authorization': `Bearer ${token}` }
+        });
+        return yield response.json();
+    });
+}
+export function streamChatGPT(messages, tools, onResponse, token) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const messageId = Math.random().toString(36).substring(3);
+        const response = yield fetch(`${env.SUPABASE_URL}/functions/v1/llm`, {
+            method: 'POST',
+            body: JSON.stringify({ messages, tools, stream: true }),
+            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 = [];
+        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'), 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/dist/plugin/ObjectController.d.ts

@@ -0,0 +1,34 @@
+type PrimitiveType = 'string' | 'number' | 'boolean';
+type ObjectToolParameterType = PrimitiveType | {
+    [key: string]: ObjectToolParameter;
+} | [{
+    [key: string]: ObjectToolParameter;
+}];
+interface ObjectToolParameter {
+    type: ObjectToolParameterType;
+    description?: string;
+    enum?: string[];
+}
+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(request: ObjectRequest, token: string): Promise<any>;
+export type OnLLMResponse = (id: string, response: string, finished: boolean, toolInvocations?: any[]) => void;
+export declare function streamObject(request: ObjectRequest, onResponse: OnLLMResponse, token: string): Promise<void>;
+export {};

package/dist/plugin/ObjectController.js

@@ -0,0 +1,77 @@
+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());
+    });
+};
+import { env } from "../utils/constants";
+export function generateObject(request, token) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return yield fetch(`${env.SUPABASE_URL}/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());
+    });
+}
+export function streamObject(request, onResponse, token) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const messageId = Math.random().toString(36).substring(3);
+        const response = yield fetch(`${env.SUPABASE_URL}/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 = [];
+        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'), 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);
+    });
+}