@rimori/client 2.5.50 → 2.5.51

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

@@ -129,12 +129,17 @@ export declare class AIModule {
      * @param params.cache Whether to cache the result by prompt hash (default: true).
      * @param params.aspectRatio Shape + size preset for the image (default: 'square_medium').
      *   `small` ≈ 200px on the longest edge, `medium` ≈ 512px, `big` keeps native HD resolution.
+     * @param params.bypassCache Force a fresh generation even if a cached image exists for this
+     *   prompt, and overwrite that cache entry with the new result — use for a "regenerate, this
+     *   looks bad" action so later callers get the improved image too. Unlike `cache: false`
+     *   (which never reads OR writes the shared cache), this still writes it.
      * @returns `{ url, cached }` where `url` is a stored CDN URL.
      */
     getImage(params: {
         prompt: string;
         cache?: boolean;
         aspectRatio?: ImageAspectRatio;
+        bypassCache?: boolean;
     }): Promise<{
         url: string;
         cached: boolean;

package/dist/plugin/module/AIModule.js

@@ -127,16 +127,21 @@ export class AIModule {
      * @param params.cache Whether to cache the result by prompt hash (default: true).
      * @param params.aspectRatio Shape + size preset for the image (default: 'square_medium').
      *   `small` ≈ 200px on the longest edge, `medium` ≈ 512px, `big` keeps native HD resolution.
+     * @param params.bypassCache Force a fresh generation even if a cached image exists for this
+     *   prompt, and overwrite that cache entry with the new result — use for a "regenerate, this
+     *   looks bad" action so later callers get the improved image too. Unlike `cache: false`
+     *   (which never reads OR writes the shared cache), this still writes it.
      * @returns `{ url, cached }` where `url` is a stored CDN URL.
      */
     async getImage(params) {
-        const { prompt, cache = true, aspectRatio = 'square_medium' } = params;
+        const { prompt, cache = true, aspectRatio = 'square_medium', bypassCache = false } = params;
         const response = await this.controller.fetchBackend('/ai/image', {
             method: 'POST',
             body: JSON.stringify({
                 prompt,
                 cache,
                 aspectRatio,
+                bypassCache,
                 session_token_id: this.sessionTokenId ?? undefined,
             }),
         });

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

@@ -2,6 +2,7 @@ import { ObjectTool } from '../../fromRimori/PluginTypes';
 import { SupabaseClient } from '../CommunicationHandler';
 import { RimoriClient } from '../RimoriClient';
 import { LanguageLevel } from '../../utils/difficultyConverter';
+import { OnStreamedObjectResult } from './AIModule';
 export type SharedContent<T> = BasicSharedContent & T;
 export type ContentStatus = 'featured' | 'community' | 'unverified';
 export type SharedContentSkillType = 'grammar' | 'reading' | 'writing' | 'speaking' | 'listening' | 'understanding';
@@ -43,6 +44,11 @@ export declare class SharedContentController {
      * @param params.skipDbSave - If true, don't save generated content to database
      * @param params.isPrivate - If true, content is guild-specific
      * @param params.ignoreSkillLevel - If true, don't filter by skill level or add skill level guidance to AI instructions
+     * @param params.onResult - When provided, the request streams: this fires with each partial
+     *   object as the LLM output arrives (e.g. a long markdown field can render progressively),
+     *   then once more with the final object and `isLoading: false`. Only fires for an actual
+     *   generation — a cache hit against existing content resolves the returned promise directly
+     *   without ever calling it.
      * @returns Existing or newly generated shared content item
      */
     getNew<T>(params: {
@@ -58,7 +64,14 @@ export declare class SharedContentController {
         skipDbSave?: boolean;
         isPrivate?: boolean;
         ignoreSkillLevel?: boolean;
+        onResult?: OnStreamedObjectResult<Partial<SharedContent<T>>>;
     }): Promise<SharedContent<T>>;
+    /**
+     * SSE variant of `getNew` — same request/response shape, but reads the response as a stream of
+     * `data: {...}\n\n` frames (mirrors the framing `AIModule.getStreamedObject` parses off
+     * `/ai/llm`) and calls `onResult` with each partial object, then the final one.
+     */
+    private getNewStreamed;
     /**
      * Search for shared content by topic using RAG (semantic similarity).
      * Returns the first matching content that hasn't been completed by the user.

package/dist/plugin/module/SharedContentController.js

@@ -20,31 +20,89 @@ export class SharedContentController {
      * @param params.skipDbSave - If true, don't save generated content to database
      * @param params.isPrivate - If true, content is guild-specific
      * @param params.ignoreSkillLevel - If true, don't filter by skill level or add skill level guidance to AI instructions
+     * @param params.onResult - When provided, the request streams: this fires with each partial
+     *   object as the LLM output arrives (e.g. a long markdown field can render progressively),
+     *   then once more with the final object and `isLoading: false`. Only fires for an actual
+     *   generation — a cache hit against existing content resolves the returned promise directly
+     *   without ever calling it.
      * @returns Existing or newly generated shared content item
      */
     async getNew(params) {
+        const requestBody = {
+            tableName: params.table,
+            skillType: params.skillType,
+            placeholders: params.placeholders,
+            filter: params.filter,
+            customFields: params.customFields,
+            tool: params.tool,
+            options: {
+                skipDbSave: params.skipDbSave,
+                isPrivate: params.isPrivate,
+                ignoreSkillLevel: params.ignoreSkillLevel,
+            },
+        };
+        if (params.onResult) {
+            return this.getNewStreamed(requestBody, params.onResult);
+        }
         // Generate new content via backend endpoint
         const response = await this.rimoriClient.runtime.fetchBackend('/shared-content/generate', {
             method: 'POST',
-            body: JSON.stringify({
-                tableName: params.table,
-                skillType: params.skillType,
-                placeholders: params.placeholders,
-                filter: params.filter,
-                customFields: params.customFields,
-                tool: params.tool,
-                options: {
-                    skipDbSave: params.skipDbSave,
-                    isPrivate: params.isPrivate,
-                    ignoreSkillLevel: params.ignoreSkillLevel,
-                },
-            }),
+            body: JSON.stringify(requestBody),
         });
         if (!response.ok) {
             throw new Error(`Failed to generate shared content: ${response.statusText}`);
         }
         return await response.json();
     }
+    /**
+     * SSE variant of `getNew` — same request/response shape, but reads the response as a stream of
+     * `data: {...}\n\n` frames (mirrors the framing `AIModule.getStreamedObject` parses off
+     * `/ai/llm`) and calls `onResult` with each partial object, then the final one.
+     */
+    async getNewStreamed(requestBody, onResult) {
+        const response = await this.rimoriClient.runtime.fetchBackend('/shared-content/generate', {
+            method: 'POST',
+            body: JSON.stringify({ ...requestBody, stream: true }),
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to generate shared content: ${response.statusText}`);
+        }
+        if (!response.body) {
+            throw new Error('No response body.');
+        }
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder('utf-8');
+        let currentObject = {};
+        // See AIModule.streamObject — a chunk boundary can split a line mid-way, so an incomplete
+        // trailing line is buffered and prepended to the next chunk rather than parsed as-is.
+        let lineBuffer = '';
+        while (true) {
+            const { value, done } = await reader.read();
+            if (done)
+                break;
+            if (!value)
+                continue;
+            const combined = lineBuffer + decoder.decode(value, { stream: true });
+            const parts = combined.split('\n');
+            lineBuffer = parts.pop() ?? '';
+            for (const line of parts.filter((l) => l.trim())) {
+                if (line.startsWith('error:')) {
+                    throw new Error(JSON.parse(line.slice(6).trim()).message ?? 'Error generating shared content');
+                }
+                if (!line.startsWith('data:'))
+                    continue;
+                const dataStr = line.slice(5).trim();
+                if (dataStr === '[DONE]') {
+                    onResult(currentObject, false);
+                    return currentObject;
+                }
+                currentObject = JSON.parse(dataStr);
+                onResult(currentObject, true);
+            }
+        }
+        onResult(currentObject, false);
+        return currentObject;
+    }
     /**
      * Search for shared content by topic using RAG (semantic similarity).
      * Returns the first matching content that hasn't been completed by the user.

package/package.json

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