@rimori/client 2.5.10 → 2.5.11-next.1

package/dist/controller/SettingsController.js

@@ -63,8 +63,8 @@ export class SettingsController {
                 .eq('guild_id', this.guild.id)
                 .eq('is_guild_setting', isGuildSetting);
             const { data: updatedRows, error: updateError } = yield (isGuildSetting
-                ? updateQuery.is('user_id', null).select('id')
-                : updateQuery.select('id'));
+                ? updateQuery.is('user_id', null).select()
+                : updateQuery.select());
             if (updateError) {
                 if (updateError.code === '42501' || ((_a = updateError.message) === null || _a === void 0 ? void 0 : _a.includes('policy'))) {
                     throw new Error(`Cannot set ${isGuildSetting ? 'guild' : 'user'} settings: Permission denied.`);

package/dist/controller/TranslationController.d.ts

@@ -1,7 +1,5 @@
 import { ThirdPartyModule, TOptions } from 'i18next';
-import { ObjectRequest } from './ObjectController';
 import { AIModule } from '../plugin/module/AIModule';
-export type AIObjectGenerator = <T>(request: ObjectRequest) => Promise<T>;
 /**
  * Translator class for handling internationalization
  */

package/dist/controller/TranslationController.js

@@ -158,9 +158,10 @@ export class Translator {
                 if (!this.ai || this.currentLanguage === 'en')
                     return text;
                 const response = yield this.ai.getObject({
-                    behaviour: 'You are a translation engine. Return only the translated text.' + additionalInstructions,
-                    instructions: `Translate the following text into ${this.currentLanguage}: ${text}`,
-                    tool: {
+                    systemPrompt: 'You are a translation engine. Return only the translated text.' + additionalInstructions,
+                    userPrompt: `Translate the following text into ${this.currentLanguage}: ${text}`,
+                    cache: true,
+                    responseSchema: {
                         translation: {
                             type: 'string',
                             description: `The translation of the input text into ${this.currentLanguage}.`,

package/dist/controller/VoiceController.d.ts

@@ -5,5 +5,6 @@ interface TTSRequest {
     voice: string;
     speed: number;
     language?: string;
+    cache?: boolean;
 }
 export {};

package/dist/fromRimori/PluginTypes.d.ts

@@ -18,6 +18,12 @@ export interface PluginPage {
     action?: {
         key: string;
         parameters: ObjectTool;
+        supportive_tools?: {
+            key: string;
+            event: string;
+            description: string;
+            parameters?: ObjectTool;
+        }[];
     };
 }
 export interface SidebarPage {

package/dist/index.d.ts

@@ -12,7 +12,7 @@ export type { TOptions } from 'i18next';
 export type { SharedContent, BasicSharedContent, ContentStatus } from './plugin/module/SharedContentController';
 export type { Exercise } from './plugin/module/ExerciseModule';
 export type { UserInfo, Language, UserRole } from './controller/SettingsController';
-export type { Message, ToolInvocation } from './controller/AIController';
+export type { Message, ToolInvocation } from './plugin/module/AIModule';
 export type { TriggerAction } from './plugin/module/ExerciseModule';
 export type { MacroAccomplishmentPayload, MicroAccomplishmentPayload } from './controller/AccomplishmentController';
 export type { EventBusMessage } from './fromRimori/EventBus';

package/dist/plugin/module/AIModule.d.ts

@@ -1,7 +1,56 @@
-import { RimoriCommunicationHandler, RimoriInfo } from '../CommunicationHandler';
-import { Message, OnLLMResponse } from '../../controller/AIController';
-import { ObjectRequest } from '../../controller/ObjectController';
 import { Tool } from '../../fromRimori/PluginTypes';
+import { RimoriCommunicationHandler, RimoriInfo } from '../CommunicationHandler';
+export type OnStreamedObjectResult<T = any> = (result: T, isLoading: boolean) => void;
+type PrimitiveType = 'string' | 'number' | 'boolean';
+type ObjectToolParameterType = PrimitiveType | {
+    [key: string]: ObjectToolParameter;
+} | [{
+    [key: string]: ObjectToolParameter;
+}];
+interface ObjectToolParameter {
+    type: ObjectToolParameterType;
+    description?: string;
+    enum?: string[];
+    optional?: boolean;
+}
+/**
+ * The tools that the AI can use.
+ *
+ * The key is the name of the tool.
+ * The value is the parameter of the tool.
+ *
+ */
+export type ObjectTool = {
+    [key: string]: ObjectToolParameter;
+};
+export interface ToolInvocation {
+    toolCallId: string;
+    toolName: string;
+    args: Record<string, string>;
+}
+export interface Message {
+    id?: string;
+    role: 'user' | 'assistant' | 'system';
+    content: string;
+    toolCalls?: ToolInvocation[];
+}
+export type OnLLMResponse = (id: string, response: string, finished: boolean, toolInvocations?: ToolInvocation[]) => void;
+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;
+}
 /**
  * Controller for AI-related operations.
  * Provides access to text generation, voice synthesis, and object generation.
@@ -15,41 +64,62 @@ export declare class AIModule {
      * Generate text from messages using AI.
      * @param messages The messages to generate text from.
      * @param tools Optional tools to use for generation.
+     * @param cache Whether to cache the result (default: false).
      * @returns The generated text.
      */
-    getText(messages: Message[], tools?: Tool[]): Promise<string>;
+    getText(messages: Message[], tools?: Tool[], cache?: boolean): Promise<string>;
     /**
      * Stream text generation from messages using AI.
      * @param messages The messages to generate text from.
      * @param onMessage Callback for each message chunk.
      * @param tools Optional tools to use for generation.
+     * @param cache Whether to cache the result (default: false).
      */
-    getSteamedText(messages: Message[], onMessage: OnLLMResponse, tools?: Tool[]): Promise<void>;
+    getSteamedText(messages: Message[], onMessage: OnLLMResponse, tools?: Tool[], cache?: boolean): Promise<void>;
     /**
      * Generate voice audio from text using AI.
      * @param text The text to convert to voice.
      * @param voice The voice to use (default: 'alloy').
      * @param speed The speed of the voice (default: 1).
      * @param language Optional language for the voice.
+     * @param cache Whether to cache the result (default: false).
      * @returns The generated audio as a Blob.
      */
-    getVoice(text: string, voice?: string, speed?: number, language?: string): Promise<Blob>;
+    getVoice(text: string, voice?: string, speed?: number, language?: string, cache?: boolean): Promise<Blob>;
     /**
      * Convert voice audio to text using AI.
      * @param file The audio file to convert.
      * @returns The transcribed text.
      */
     getTextFromVoice(file: Blob): Promise<string>;
+    private getChatMessage;
     /**
      * Generate a structured object from a request using AI.
      * @param request The object generation request.
      * @returns The generated object.
      */
-    getObject<T = any>(request: ObjectRequest): Promise<T>;
+    getObject<T = any>(params: {
+        systemPrompt: string;
+        responseSchema: ObjectTool;
+        userPrompt?: string;
+        cache?: boolean;
+        tools?: Tool[];
+    }): Promise<T>;
     /**
      * Generate a streamed structured object from a request using AI.
      * @param request The object generation request.
      * @param onResult Callback for each result chunk.
+     * @param cache Whether to cache the result (default: false).
      */
-    getStreamedObject<T = any>(request: ObjectRequest, onResult: (result: T, isLoading: boolean) => void): Promise<void>;
+    getStreamedObject<T = any>(params: {
+        systemPrompt: string;
+        responseSchema: ObjectTool;
+        userPrompt?: string;
+        onResult: OnStreamedObjectResult<T>;
+        cache?: boolean;
+        tools?: Tool[];
+    }): Promise<void>;
+    private streamObject;
+    private sendToolResult;
 }
+export {};

package/dist/plugin/module/AIModule.js

@@ -7,8 +7,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { generateText, streamChatGPT } from '../../controller/AIController';
-import { generateObject, streamObject } from '../../controller/ObjectController';
 import { getSTTResponse, getTTSResponse } from '../../controller/VoiceController';
 /**
  * Controller for AI-related operations.
@@ -27,11 +25,22 @@ export class AIModule {
      * Generate text from messages using AI.
      * @param messages The messages to generate text from.
      * @param tools Optional tools to use for generation.
+     * @param cache Whether to cache the result (default: false).
      * @returns The generated text.
      */
-    getText(messages, tools) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return generateText(this.backendUrl, messages, tools || [], this.token).then(({ messages }) => messages[0].content[0].text);
+    getText(messages_1, tools_1) {
+        return __awaiter(this, arguments, void 0, function* (messages, tools, cache = false) {
+            const { result } = yield this.streamObject({
+                cache,
+                tools,
+                messages,
+                responseSchema: {
+                    result: {
+                        type: 'string',
+                    },
+                },
+            });
+            return result;
         });
     }
     /**
@@ -39,10 +48,23 @@ export class AIModule {
      * @param messages The messages to generate text from.
      * @param onMessage Callback for each message chunk.
      * @param tools Optional tools to use for generation.
+     * @param cache Whether to cache the result (default: false).
      */
-    getSteamedText(messages, onMessage, tools) {
-        return __awaiter(this, void 0, void 0, function* () {
-            streamChatGPT(this.backendUrl, messages, tools || [], onMessage, this.token);
+    getSteamedText(messages_1, onMessage_1, tools_1) {
+        return __awaiter(this, arguments, void 0, function* (messages, onMessage, tools, cache = false) {
+            const messageId = Math.random().toString(36).substring(3);
+            const { result } = yield this.streamObject({
+                cache,
+                tools,
+                messages,
+                responseSchema: {
+                    result: {
+                        type: 'string',
+                    },
+                },
+                onResult: ({ result }) => onMessage(messageId, result, false),
+            });
+            onMessage(messageId, result, true);
         });
     }
     /**
@@ -51,11 +73,12 @@ export class AIModule {
      * @param voice The voice to use (default: 'alloy').
      * @param speed The speed of the voice (default: 1).
      * @param language Optional language for the voice.
+     * @param cache Whether to cache the result (default: false).
      * @returns The generated audio as a Blob.
      */
     getVoice(text_1) {
-        return __awaiter(this, arguments, void 0, function* (text, voice = 'alloy', speed = 1, language) {
-            return getTTSResponse(this.backendUrl, { input: text, voice, speed, language }, this.token);
+        return __awaiter(this, arguments, void 0, function* (text, voice = 'alloy', speed = 1, language, cache = false) {
+            return getTTSResponse(this.backendUrl, { input: text, voice, speed, language, cache }, this.token);
         });
     }
     /**
@@ -68,24 +91,139 @@ export class AIModule {
             return getSTTResponse(this.backendUrl, file, this.token);
         });
     }
+    getChatMessage(systemPrompt, userPrompt) {
+        const messages = [{ role: 'system', content: systemPrompt }];
+        if (userPrompt) {
+            messages.push({ role: 'user', content: userPrompt });
+        }
+        return messages;
+    }
     /**
      * Generate a structured object from a request using AI.
      * @param request The object generation request.
      * @returns The generated object.
      */
-    getObject(request) {
+    getObject(params) {
         return __awaiter(this, void 0, void 0, function* () {
-            return generateObject(this.backendUrl, request, this.token);
+            const { systemPrompt, responseSchema, userPrompt, cache = false, tools = [] } = params;
+            return yield this.streamObject({
+                responseSchema,
+                messages: this.getChatMessage(systemPrompt, userPrompt),
+                cache,
+                tools,
+            });
         });
     }
     /**
      * Generate a streamed structured object from a request using AI.
      * @param request The object generation request.
      * @param onResult Callback for each result chunk.
+     * @param cache Whether to cache the result (default: false).
      */
-    getStreamedObject(request, onResult) {
+    getStreamedObject(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { systemPrompt, responseSchema, userPrompt, onResult, cache = false, tools = [] } = params;
+            yield this.streamObject({
+                responseSchema,
+                messages: this.getChatMessage(systemPrompt, userPrompt),
+                onResult,
+                cache,
+                tools,
+            });
+        });
+    }
+    streamObject(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            console.log('todo: move this function into the AI Module');
+            const { messages, responseSchema, onResult = () => null, cache = false, tools = [] } = params;
+            const chatMessages = messages.map((message, index) => (Object.assign(Object.assign({}, message), { id: `${index + 1}` })));
+            const response = yield fetch(`${this.backendUrl}/ai/llm`, {
+                method: 'POST',
+                body: JSON.stringify({
+                    stream: true,
+                    messages: chatMessages,
+                    responseSchema,
+                    cache,
+                    tools,
+                }),
+                headers: { Authorization: `Bearer ${this.token}`, 'Content-Type': 'application/json' },
+            });
+            if (!response.ok) {
+                throw new Error(`Failed to stream object: ${response.status} ${response.statusText}`);
+            }
+            if (!response.body) {
+                throw new Error('No response body.');
+            }
+            const reader = response.body.getReader();
+            const decoder = new TextDecoder('utf-8');
+            let currentObject = {};
+            let isLoading = true;
+            while (isLoading) {
+                //wait 50ms to not overload the CPU
+                yield new Promise((resolve) => setTimeout(resolve, 30));
+                const { value, done: readerDone } = yield reader.read();
+                if (readerDone) {
+                    isLoading = false;
+                    onResult(currentObject, false);
+                    return currentObject;
+                }
+                //the check needs to be behind readerDone because in closed connections the value is undefined
+                if (!value)
+                    continue;
+                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, 5);
+                    const dataStr = line.substring(5).trim();
+                    if (dataStr === '[DONE]') {
+                        isLoading = false;
+                        onResult(currentObject, false);
+                        return currentObject;
+                    }
+                    if (command === 'data:') {
+                        currentObject = JSON.parse(dataStr);
+                        onResult(currentObject, true);
+                    }
+                    else if (command === 'tool:') {
+                        const { toolCallId, toolName, args } = JSON.parse(dataStr);
+                        const tool = tools.find((tool) => tool.name === toolName);
+                        if (tool && tool.execute) {
+                            const result = yield tool.execute(args);
+                            // Send the result to the backend
+                            yield this.sendToolResult(toolCallId, result);
+                        }
+                        else if (tool && !tool.execute) {
+                            console.error('Tool found but has no execute function:', toolName);
+                        }
+                        else {
+                            console.error('Tool not found:', toolName);
+                        }
+                    }
+                    else if (command === 'error') {
+                        //error has 5 letters + the colon so we need to remove one character of the data string to get the error message
+                        console.error('Error:', dataStr.substring(1));
+                    }
+                    else if (command === 'info:') {
+                        //ignore info messages
+                    }
+                    else {
+                        console.error('Unknown stream data:', line);
+                    }
+                }
+            }
+            return currentObject;
+        });
+    }
+    sendToolResult(toolCallId, result) {
         return __awaiter(this, void 0, void 0, function* () {
-            return streamObject(this.backendUrl, request, onResult, this.token);
+            yield fetch(`${this.backendUrl}/ai/llm/tool_result`, {
+                method: 'POST',
+                body: JSON.stringify({
+                    toolCallId,
+                    result: result !== null && result !== void 0 ? result : '[DONE]',
+                }),
+                headers: { Authorization: `Bearer ${this.token} `, 'Content-Type': 'application/json' },
+            });
         });
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rimori/client",
-  "version": "2.5.10",
+  "version": "2.5.11-next.1",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "repository": {

package/dist/controller/AIController.d.ts

@@ -1,15 +0,0 @@
-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 declare function generateText(backendUrl: string, messages: Message[], tools: Tool[], token: string): Promise<any>;
-export type OnLLMResponse = (id: string, response: string, finished: boolean, toolInvocations?: ToolInvocation[]) => void;
-export declare function streamChatGPT(backendUrl: string, messages: Message[], tools: Tool[], onResponse: OnLLMResponse, token: string): Promise<void>;

package/dist/controller/AIController.js

@@ -1,255 +0,0 @@
-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());
-    });
-};
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
-export function generateText(backendUrl, messages, tools, token) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const response = yield fetch(`${backendUrl}/ai/llm`, {
-            method: 'POST',
-            body: JSON.stringify({ messages, tools }),
-            headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/json' },
-        });
-        return yield response.json();
-    });
-}
-export function streamChatGPT(backendUrl, messages, tools, onResponse, token) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const messageId = Math.random().toString(36).substring(3);
-        const currentMessages = [...messages];
-        console.log('Starting streamChatGPT with:', {
-            messageId,
-            messageCount: messages.length,
-            toolCount: tools.length,
-            backendUrl,
-        });
-        while (true) {
-            const messagesForApi = currentMessages.map((_a) => {
-                var { id } = _a, rest = __rest(_a, ["id"]);
-                return rest;
-            });
-            try {
-                const response = yield fetch(`${backendUrl}/ai/llm`, {
-                    method: 'POST',
-                    body: JSON.stringify({ messages: messagesForApi, tools, stream: true }),
-                    headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/json' },
-                });
-                if (!response.ok) {
-                    throw new Error(`HTTP error! status: ${response.status}`);
-                }
-                if (!response.body) {
-                    console.error('No response body.');
-                    return;
-                }
-                const reader = response.body.getReader();
-                const decoder = new TextDecoder('utf-8');
-                let content = '';
-                let done = false;
-                const toolInvocations = [];
-                let currentTextId = '';
-                let isToolCallMode = false;
-                let buffer = ''; // Buffer for incomplete chunks
-                while (!done) {
-                    const { value, done: readerDone } = yield reader.read();
-                    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() || '';
-                        }
-                        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;
-                                    break;
-                                }
-                                try {
-                                    const data = JSON.parse(dataStr);
-                                    // Log the first message to understand the format
-                                    if (!content && !isToolCallMode) {
-                                        // console.log('First stream message received:', data);
-                                    }
-                                    switch (data.type) {
-                                        case 'start':
-                                            // Stream started, no action needed
-                                            // console.log('Stream started');
-                                            break;
-                                        case 'start-step':
-                                            // Step started, no action needed
-                                            // 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) {
-                                                content += data.delta;
-                                                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');
-                                            break;
-                                        case 'finish':
-                                            // 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 || data.input)) {
-                                                toolInvocations.push({
-                                                    toolCallId: data.toolCallId,
-                                                    toolName: data.toolName,
-                                                    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);
-                                            break;
-                                    }
-                                }
-                                catch (error) {
-                                    console.error('Error parsing stream data:', error, dataStr);
-                                }
-                            }
-                        }
-                    }
-                    if (readerDone) {
-                        done = true;
-                    }
-                }
-                // Check if we have content or if this was a tool call response
-                if (content || toolInvocations.length > 0) {
-                    currentMessages.push({
-                        id: messageId,
-                        role: 'assistant',
-                        content: content,
-                        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 = [];
-                    for (const toolInvocation of toolInvocations) {
-                        const tool = tools.find((t) => t.name === toolInvocation.toolName);
-                        if (tool && tool.execute) {
-                            try {
-                                const result = yield 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}`,
-                                });
-                            }
-                        }
-                    }
-                    if (toolResults.length > 0) {
-                        currentMessages.push(...toolResults);
-                        // Continue the loop to handle the next response
-                        continue;
-                    }
-                }
-                // Since the new format doesn't seem to support tool calls in the same way,
-                // we'll assume the stream is complete when we reach the end
-                // If tools are provided and no content was generated, this might indicate a tool call
-                if (tools.length > 0 && !content && !isToolCallMode) {
-                    // This might be a tool call scenario, but we need more information
-                    // For now, we'll just finish the stream
-                    console.log('No content generated, but tools provided - might be tool call scenario');
-                }
-                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, []);
-                return;
-            }
-        }
-    });
-}

package/dist/controller/ObjectController.d.ts

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

package/dist/controller/ObjectController.js

@@ -1,105 +0,0 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-export function generateObject(backendUrl, request, token) {
-    return __awaiter(this, void 0, void 0, function* () {
-        return yield fetch(`${backendUrl}/ai/llm-object`, {
-            method: 'POST',
-            body: JSON.stringify({
-                stream: false,
-                tool: request.tool,
-                behaviour: request.behaviour,
-                instructions: request.instructions,
-            }),
-            headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/json' },
-        }).then((response) => response.json());
-    });
-}
-const tryParseJson = (value) => {
-    try {
-        return JSON.parse(value);
-    }
-    catch (_a) {
-        return null;
-    }
-};
-const mergeStreamObject = (base, patch) => {
-    if (Array.isArray(patch)) {
-        return patch.map((item, index) => mergeStreamObject(base === null || base === void 0 ? void 0 : base[index], item));
-    }
-    if (patch && typeof patch === 'object') {
-        const result = base && typeof base === 'object' && !Array.isArray(base) ? Object.assign({}, base) : {};
-        for (const [key, value] of Object.entries(patch)) {
-            result[key] = mergeStreamObject(result[key], value);
-        }
-        return result;
-    }
-    return patch;
-};
-const applyStreamChunk = (current, chunk) => {
-    if (!chunk || typeof chunk !== 'object') {
-        return { next: current, updated: false };
-    }
-    if (chunk.object && typeof chunk.object === 'object') {
-        return { next: chunk.object, updated: true };
-    }
-    if (chunk.delta && typeof chunk.delta === 'object') {
-        return { next: mergeStreamObject(current, chunk.delta), updated: true };
-    }
-    if (chunk.value && typeof chunk.value === 'object') {
-        return { next: mergeStreamObject(current, chunk.value), updated: true };
-    }
-    return { next: current, updated: false };
-};
-export function streamObject(backendUrl, request, onResult, token) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const response = yield fetch(`${backendUrl}/ai/llm-object`, {
-            method: 'POST',
-            body: JSON.stringify({
-                stream: true,
-                tool: request.tool,
-                behaviour: request.behaviour,
-                instructions: request.instructions,
-            }),
-            headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/json' },
-        });
-        if (!response.ok) {
-            console.error('Failed to stream object:', response.status, response.statusText);
-            return;
-        }
-        if (!response.body) {
-            console.error('No response body.');
-            return;
-        }
-        const reader = response.body.getReader();
-        const decoder = new TextDecoder('utf-8');
-        let done = false;
-        let currentObject = {};
-        while (!done) {
-            const { value, done: readerDone } = 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 dataStr = line.substring(5).trim();
-                    if (dataStr === '[DONE]') {
-                        done = true;
-                        break;
-                    }
-                    currentObject = JSON.parse(dataStr);
-                    onResult(currentObject, true);
-                }
-            }
-            if (readerDone) {
-                done = true;
-            }
-        }
-        onResult(currentObject, false);
-    });
-}