@rimori/client 2.5.8-next.0 → 2.5.8-next.2

package/dist/controller/ObjectController.d.ts

@@ -37,6 +37,6 @@ export interface ObjectRequest {
     instructions: string;
 }
 export declare function generateObject<T = any>(backendUrl: string, request: ObjectRequest, token: string): Promise<T>;
-export type OnLLMResponse = (id: string, response: string, finished: boolean, toolInvocations?: any[]) => void;
-export declare function streamObject(backendUrl: string, request: ObjectRequest, onResponse: OnLLMResponse, token: string): Promise<void>;
+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

@@ -21,56 +21,85 @@ export function generateObject(backendUrl, request, token) {
         }).then((response) => response.json());
     });
 }
-export function streamObject(backendUrl, request, onResponse, token) {
+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 messageId = Math.random().toString(36).substring(3);
         const response = yield fetch(`${backendUrl}/ai/llm-object`, {
             method: 'POST',
             body: JSON.stringify({
                 stream: true,
-                tools: request.tool,
-                systemInstructions: request.behaviour,
-                secondaryInstructions: request.instructions,
+                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 content = '';
         let done = false;
-        const toolInvocations = [];
+        let currentObject = {};
         while (!done) {
-            const { value } = yield reader.read();
+            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() !== '');
+                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').replace(/\\+"/g, '"'), false);
-                    }
-                    else if (command === 'd') {
-                        // console.log("AI usage:", JSON.parse(line.substring(2)));
+                    const dataStr = line.substring(5).trim();
+                    if (dataStr === '[DONE]') {
                         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)));
-                    }
+                    currentObject = JSON.parse(dataStr);
+                    onResult(currentObject, true);
                 }
             }
+            if (readerDone) {
+                done = true;
+            }
         }
-        onResponse(messageId, content.replace(/\\n/g, '\n').replace(/\\+"/g, '"'), true, toolInvocations);
+        onResult(currentObject, false);
     });
 }

package/dist/plugin/CommunicationHandler.js

@@ -80,7 +80,7 @@ export class RimoriCommunicationHandler {
             // Listen for updates from rimori-main (data changes, token refresh, etc.)
             // Topic format: {pluginId}.supabase.triggerUpdate
             EventBus.on(`${this.pluginId}.supabase.triggerUpdate`, (ev) => {
-                console.log('[RimoriCommunicationHandler] Received update from rimori-main', ev.data);
+                // console.log('[RimoriCommunicationHandler] Received update from rimori-main', ev.data);
                 this.handleRimoriInfoUpdate(ev.data);
             });
             // Mark MessageChannel as ready and process pending requests
@@ -211,7 +211,7 @@ export class RimoriCommunicationHandler {
      */
     handleRimoriInfoUpdate(newInfo) {
         if (JSON.stringify(this.rimoriInfo) === JSON.stringify(newInfo)) {
-            console.log('[RimoriCommunicationHandler] RimoriInfo update is the same as the cached info, skipping update');
+            // console.log('[RimoriCommunicationHandler] RimoriInfo update is the same as the cached info, skipping update');
             return;
         }
         // Update cached rimoriInfo

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

@@ -46,4 +46,10 @@ export declare class AIModule {
      * @returns The generated object.
      */
     getObject<T = any>(request: ObjectRequest): 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.
+     */
+    getStreamedObject<T = any>(request: ObjectRequest, onResult: (result: T, isLoading: boolean) => void): Promise<void>;
 }

package/dist/plugin/module/AIModule.js

@@ -8,7 +8,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import { generateText, streamChatGPT } from '../../controller/AIController';
-import { generateObject } from '../../controller/ObjectController';
+import { generateObject, streamObject } from '../../controller/ObjectController';
 import { getSTTResponse, getTTSResponse } from '../../controller/VoiceController';
 /**
  * Controller for AI-related operations.
@@ -78,4 +78,14 @@ export class AIModule {
             return generateObject(this.backendUrl, request, this.token);
         });
     }
+    /**
+     * Generate a streamed structured object from a request using AI.
+     * @param request The object generation request.
+     * @param onResult Callback for each result chunk.
+     */
+    getStreamedObject(request, onResult) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return streamObject(this.backendUrl, request, onResult, this.token);
+        });
+    }
 }

package/dist/utils/difficultyConverter.d.ts

@@ -2,3 +2,11 @@ export type LanguageLevel = 'Pre-A1' | 'A1' | 'A2' | 'B1' | 'B2' | 'C1' | 'C2' |
 export declare function getDifficultyLevel(difficulty: LanguageLevel): number;
 export declare function getDifficultyLabel(difficulty: number): LanguageLevel;
 export declare function getNeighborDifficultyLevel(difficulty: LanguageLevel, difficultyAdjustment: number): LanguageLevel;
+/**
+ * Compares two LanguageLevel values to determine their relative order.
+ * Returns:
+ * - negative number if level1 < level2
+ * - 0 if level1 === level2
+ * - positive number if level1 > level2
+ */
+export declare function compareLanguageLevels(level1: LanguageLevel, level2: LanguageLevel): number;

package/dist/utils/difficultyConverter.js

@@ -8,3 +8,13 @@ export function getDifficultyLabel(difficulty) {
 export function getNeighborDifficultyLevel(difficulty, difficultyAdjustment) {
     return getDifficultyLabel(getDifficultyLevel(difficulty) + difficultyAdjustment - 1);
 }
+/**
+ * Compares two LanguageLevel values to determine their relative order.
+ * Returns:
+ * - negative number if level1 < level2
+ * - 0 if level1 === level2
+ * - positive number if level1 > level2
+ */
+export function compareLanguageLevels(level1, level2) {
+    return getDifficultyLevel(level1) - getDifficultyLevel(level2);
+}

package/package.json

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