@rimori/client 2.5.44 → 2.5.45

package/dist/fromRimori/EventBus.d.ts

@@ -39,6 +39,13 @@ export declare class EventBusHandler {
      * Starts the interval to cleanup the generated ids.
      */
     private startIdCleanup;
+    /**
+     * Generates a unique id for correlating a stream of chunk events.
+     * Exposed for the streaming primitive (`requestStream`/`respondStream`), which carries
+     * this id inside the payload (`__streamId`) rather than relying on a one-shot `eventId`.
+     * @returns A unique id.
+     */
+    generateStreamId(): number;
     /**
      * Generates a unique id.
      * @returns A unique id.

package/dist/fromRimori/EventBus.js

@@ -46,6 +46,15 @@ export class EventBusHandler {
             }
         }, 10000); // Run every 10 seconds
     }
+    /**
+     * Generates a unique id for correlating a stream of chunk events.
+     * Exposed for the streaming primitive (`requestStream`/`respondStream`), which carries
+     * this id inside the payload (`__streamId`) rather than relying on a one-shot `eventId`.
+     * @returns A unique id.
+     */
+    generateStreamId() {
+        return this.generateUniqueId();
+    }
     /**
      * Generates a unique id.
      * @returns A unique id.

package/dist/fromRimori/PluginTypes.d.ts

@@ -32,6 +32,7 @@ export interface SidebarPage {
     description: string;
     url: string;
     icon: string;
+    hideInExtension?: boolean;
 }
 export interface MenuEntry {
     plugin_id: string;
@@ -39,6 +40,7 @@ export interface MenuEntry {
     text: string;
     iconUrl?: string;
     args?: Record<string, unknown>;
+    hideInExtension?: boolean;
 }
 export type MainPanelAction = {
     plugin_id: string;
@@ -156,7 +158,7 @@ export type ObjectTool = {
  * Defines the structure, validation rules, and metadata for individual tool parameters.
  * Used to create type-safe interfaces between LLMs, plugins, and the Rimori platform.
  */
-interface ToolParameter {
+export interface ToolParameter {
     /** The data type of the parameter - can be primitive, nested object, or array */
     type: ToolParameterType;
     /** Human-readable description of the parameter's purpose and usage */
@@ -167,6 +169,26 @@ interface ToolParameter {
     optional?: boolean;
     /** Whether the parameter is an array */
     isArray?: boolean;
+    /**
+     * For id-like parameters: a relative event topic (no pluginId prefix) that the owning plugin
+     * answers with the selectable options for this parameter. The responder must return
+     * `OptionItem[]` ({ title, value }). The host (rimori-main) requests this on the owning plugin —
+     * served headlessly by the plugin's web worker — and renders a dropdown of human-readable titles
+     * instead of a free-text id input. Topic must follow the event convention, e.g. `deck.requestOptions`.
+     */
+    optionsEvent?: string;
+}
+/**
+ * A single selectable option returned by a parameter's `optionsEvent` responder.
+ * `title` is shown to the user; `value` is what gets stored in the action parameter.
+ */
+export interface OptionItem {
+    /** Human-readable label shown in the dropdown */
+    title: string;
+    /** The value stored in the exercise/action parameter when this option is picked */
+    value: string;
+    /** Optional secondary label / grouping hint shown next to the title */
+    group?: string;
 }
 /**
  * Union type defining all possible parameter types for LLM tools.

package/dist/index.d.ts

@@ -11,6 +11,7 @@ export type { TOptions } from 'i18next';
 export { setupWorker } from './worker/WorkerSetup';
 export type { EventBusMessage } from './fromRimori/EventBus';
 export { AudioController } from './controller/AudioController';
+export { voiceDebug } from './plugin/VoiceDebugStore';
 export type { Exercise } from './plugin/module/ExerciseModule';
 export { Translator } from './controller/TranslationController';
 export type { TriggerAction } from './plugin/module/ExerciseModule';

package/dist/index.js

@@ -10,6 +10,7 @@ export * from './utils/difficultyConverter';
 export * from './plugin/CommunicationHandler';
 export { setupWorker } from './worker/WorkerSetup';
 export { AudioController } from './controller/AudioController';
+export { voiceDebug } from './plugin/VoiceDebugStore';
 export { Translator } from './controller/TranslationController';
 export { TIER_ORDER, ROLE_ORDER } from './plugin/module/PluginModule';
 export { StorageModule } from './plugin/module/StorageModule';

package/dist/plugin/CommunicationHandler.d.ts

@@ -54,7 +54,7 @@ export declare class RimoriCommunicationHandler {
     private isMessageChannelReady;
     private pendingRequests;
     private updateCallbacks;
-    constructor(pluginId: string, standalone: boolean);
+    constructor(pluginId: string, standalone: boolean, queryParams?: Record<string, string>);
     private initMessageChannel;
     private sendHello;
     private sendFinishedInit;

package/dist/plugin/CommunicationHandler.js

@@ -9,9 +9,13 @@ export class RimoriCommunicationHandler {
     isMessageChannelReady = false;
     pendingRequests = [];
     updateCallbacks = new Set();
-    constructor(pluginId, standalone) {
+    constructor(pluginId, standalone, 
+    // Federation mode skips the MessageChannel handshake that would normally
+    // deliver query params, so callers (createWithInfo) inject them directly here.
+    queryParams = {}) {
         this.pluginId = pluginId;
         this.getClient = this.getClient.bind(this);
+        this.queryParams = queryParams;
         //no need to forward messages to parent in standalone mode or worker context
         if (standalone)
             return;

package/dist/plugin/RimoriClient.d.ts

@@ -1,6 +1,6 @@
 import { SharedContentController } from './module/SharedContentController';
 import { RimoriInfo } from './CommunicationHandler';
-import { PluginModule } from './module/PluginModule';
+import { ApplicationMode, PluginModule } from './module/PluginModule';
 import { DbModule } from './module/DbModule';
 import { EventModule } from './module/EventModule';
 import { AIModule } from './module/AIModule';
@@ -29,7 +29,7 @@ export declare class RimoriClient {
      * Uses a fresh per-plugin EventBus instance instead of the global singleton.
      * Creates the Supabase PostgrestClient internally from the info.
      */
-    static createWithInfo(info: RimoriInfo): RimoriClient;
+    static createWithInfo(info: RimoriInfo, applicationMode?: ApplicationMode): RimoriClient;
     static getInstance(pluginId?: string): Promise<RimoriClient>;
     navigation: {
         toDashboard: () => void;

package/dist/plugin/RimoriClient.js

@@ -10,6 +10,7 @@ import { StorageModule } from './module/StorageModule';
 import { AssetsModule } from './module/AssetsModule';
 import { PostgrestClient } from '@supabase/postgrest-js';
 import { EventBus, EventBusHandler } from '../fromRimori/EventBus';
+import { voiceDebug } from './VoiceDebugStore';
 export class RimoriClient {
     static instance;
     controller;
@@ -43,15 +44,20 @@ export class RimoriClient {
         if (this.plugin.applicationMode !== 'sidebar') {
             Logger.getInstance(this);
         }
+        // Expose the dev-only simulated-speech helper (no-op on prod).
+        voiceDebug.install();
     }
     /**
      * Creates a RimoriClient with pre-existing RimoriInfo (federation mode).
      * Uses a fresh per-plugin EventBus instance instead of the global singleton.
      * Creates the Supabase PostgrestClient internally from the info.
      */
-    static createWithInfo(info) {
+    static createWithInfo(info, applicationMode = 'main') {
         const eventBus = EventBusHandler.create('Plugin EventBus ' + info.pluginId);
-        const controller = new RimoriCommunicationHandler(info.pluginId, true);
+        // Pass applicationMode as a query param so PluginModule resolves it the same way
+        // the iframe handshake would — keeps client.plugin.applicationMode correct in
+        // federation (which the context-menu / logger guards rely on).
+        const controller = new RimoriCommunicationHandler(info.pluginId, true, { applicationMode });
         controller.handleRimoriInfoUpdate(info);
         const supabase = new PostgrestClient(`${info.url}/rest/v1`, {
             schema: info.dbSchema,

package/dist/plugin/VoiceDebugStore.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Dev-only mechanism to simulate submitted speech in voice chats (e.g. discussion
+ * roleplay) so an automated agent can "speak" without a real microphone.
+ *
+ * Plugins are federated into rimori-main's own window, so plugin code shares
+ * rimori-main's `window.location.hostname`. That makes a plain hostname check the
+ * authoritative environment signal — no handshake field needed. Prod
+ * (`app.rimori.se`) is the only host where this must stay completely off.
+ *
+ * Flow: the agent queues a transcription (via `window.__rimoriVoiceDebug.queue(text)`
+ * or `voiceDebug.queue(text)`), then drives the mic UI normally. `VoiceRecorder`
+ * reads the queued text at stop time and feeds it in as if STT had returned it,
+ * bypassing the real recording + `/voice/stt` call.
+ */
+export declare const voiceDebug: {
+    /** True everywhere except prod (`app.rimori.se`), including dev and all localhost ports. */
+    isEnabled(): boolean;
+    /** Queue the text that should be treated as the next spoken/transcribed message. */
+    queue(text: string): void;
+    /** Consume the queued transcription (returns null when nothing is queued). */
+    take(): string | null;
+    /** Expose `window.__rimoriVoiceDebug` for DevTools / Playwright. Self-guards on prod. */
+    install(): void;
+};

package/dist/plugin/VoiceDebugStore.js

@@ -0,0 +1,50 @@
+/**
+ * Dev-only mechanism to simulate submitted speech in voice chats (e.g. discussion
+ * roleplay) so an automated agent can "speak" without a real microphone.
+ *
+ * Plugins are federated into rimori-main's own window, so plugin code shares
+ * rimori-main's `window.location.hostname`. That makes a plain hostname check the
+ * authoritative environment signal — no handshake field needed. Prod
+ * (`app.rimori.se`) is the only host where this must stay completely off.
+ *
+ * Flow: the agent queues a transcription (via `window.__rimoriVoiceDebug.queue(text)`
+ * or `voiceDebug.queue(text)`), then drives the mic UI normally. `VoiceRecorder`
+ * reads the queued text at stop time and feeds it in as if STT had returned it,
+ * bypassing the real recording + `/voice/stt` call.
+ */
+// Federated plugins share rimori-main's window, so the host hostname is authoritative.
+// Prod is the only place this must stay off.
+function isProdHost() {
+    return typeof window !== 'undefined' && window.location.hostname === 'app.rimori.se';
+}
+let pending = null;
+let installed = false;
+export const voiceDebug = {
+    /** True everywhere except prod (`app.rimori.se`), including dev and all localhost ports. */
+    isEnabled() {
+        return !isProdHost();
+    },
+    /** Queue the text that should be treated as the next spoken/transcribed message. */
+    queue(text) {
+        pending = text;
+        console.log('[voice-debug] queued transcription:', text);
+    },
+    /** Consume the queued transcription (returns null when nothing is queued). */
+    take() {
+        const text = pending;
+        pending = null;
+        if (text !== null)
+            console.log('[voice-debug] injected transcription:', text);
+        return text;
+    },
+    /** Expose `window.__rimoriVoiceDebug` for DevTools / Playwright. Self-guards on prod. */
+    install() {
+        if (installed || isProdHost() || typeof window === 'undefined')
+            return;
+        installed = true;
+        window.__rimoriVoiceDebug = {
+            queue: (text) => voiceDebug.queue(text),
+            enabled: true,
+        };
+    },
+};

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

@@ -31,6 +31,40 @@ export declare class EventModule {
      * @returns The response from the event.
      */
     request<T>(topic: string, data?: any): Promise<EventBusMessage<T>>;
+    /**
+     * Request a stream of items from a responder, correlated by a generated `streamId`.
+     *
+     * Unlike `request` (one-shot), the responder may `push` many items over time; each is
+     * delivered to `onItem` in arrival order. The returned promise resolves once the stream
+     * terminates (responder finished) with the full collected array, and rejects on a
+     * responder error, inactivity timeout, or abort.
+     *
+     * @param topic The streaming request topic (must use a `request`-prefixed action).
+     * @param data The request payload (the caller's session token is forwarded automatically).
+     * @param onItem Called for each streamed item as it arrives.
+     * @param options.timeoutMs Inactivity timeout, reset on each chunk (default 60s).
+     * @param options.signal Abort signal — aborting stops delivery, signals the responder, and rejects.
+     * @returns Resolves with `{ items }` on completion.
+     */
+    requestStream<TReq extends object = EventPayload, TItem = EventPayload>(topic: string, data: TReq, onItem: (item: TItem) => void, options?: {
+        timeoutMs?: number;
+        signal?: AbortSignal;
+    }): Promise<{
+        items: TItem[];
+    }>;
+    /**
+     * Respond to a streaming request (see `requestStream`). The handler receives the request
+     * message and a `push` function it calls for each item to stream back; when the handler
+     * resolves a `done` is emitted, and if it throws an `error` is emitted instead.
+     *
+     * Mirrors `respond`'s session-token handling so the streamed AI calls inside the handler
+     * are attributed to the requester's session.
+     *
+     * @param topic The streaming request topic to handle.
+     * @param handler Receives the request message and a `push(item)` callback.
+     * @returns An EventListener with an `off()` method for cleanup.
+     */
+    respondStream<TReq = EventPayload, TItem = EventPayload>(topic: string, handler: (msg: EventBusMessage<TReq>, push: (item: TItem) => void) => Promise<void>): EventListener;
     /**
      * Subscribe to an event.
      * @param topic The topic to subscribe to.

package/dist/plugin/module/EventModule.js

@@ -1,5 +1,35 @@
 import { AccomplishmentController } from '../../controller/AccomplishmentController';
 import { EventBus } from '../../fromRimori/EventBus';
+/** Default inactivity timeout for a stream — reset on every chunk received. */
+const DEFAULT_STREAM_TIMEOUT_MS = 60_000;
+/**
+ * Derives the sibling chunk/cancel topics for a streaming request.
+ *
+ * Routing matters here: the federation bridge (PluginEventBridge / CommunicationHandler)
+ * only delivers an inbound event to a plugin when the topic is in **that plugin's**
+ * namespace, is global, or is a response to one of its outstanding requests. So:
+ * - **Chunks** flow on the REQUESTER's namespace, so the bridge routes them back to the
+ *   requester. (A responder-namespaced chunk would route to the responder — the original
+ *   "stream timed out" bug.)
+ * - **Cancel** flows on the RESPONDER's namespace (derived from the request topic prefix),
+ *   so it routes to the responder regardless of which requester sent it.
+ *
+ * e.g. request `pl772.lookup.requestBulkStream` from requester `pl454`:
+ *   chunk  `pl454.lookup.triggerBulkStreamChunk`  (requester ns)
+ *   cancel `pl772.lookup.triggerBulkStreamCancel` (responder ns)
+ * The `trigger` prefix keeps both valid per `validateTopic`.
+ */
+function deriveStreamTopics(requestTopic, requesterId) {
+    const [responderId, area, action] = requestTopic.split('.');
+    // Strip a leading `request` so the derived action reads cleanly; otherwise capitalise.
+    const base = action.startsWith('request')
+        ? action.slice('request'.length)
+        : action.charAt(0).toUpperCase() + action.slice(1);
+    return {
+        chunkTopic: `${requesterId}.${area}.trigger${base}Chunk`,
+        cancelTopic: `${responderId}.${area}.trigger${base}Cancel`,
+    };
+}
 /**
  * Event module for plugin event bus operations.
  * Provides methods for emitting, listening to, and responding to events.
@@ -72,6 +102,160 @@ export class EventModule {
         const sessionToken = this.aiModule.session.get() ?? undefined;
         return this.eventBus.request(this.pluginId, globalTopic, data, sessionToken);
     }
+    /**
+     * Request a stream of items from a responder, correlated by a generated `streamId`.
+     *
+     * Unlike `request` (one-shot), the responder may `push` many items over time; each is
+     * delivered to `onItem` in arrival order. The returned promise resolves once the stream
+     * terminates (responder finished) with the full collected array, and rejects on a
+     * responder error, inactivity timeout, or abort.
+     *
+     * @param topic The streaming request topic (must use a `request`-prefixed action).
+     * @param data The request payload (the caller's session token is forwarded automatically).
+     * @param onItem Called for each streamed item as it arrives.
+     * @param options.timeoutMs Inactivity timeout, reset on each chunk (default 60s).
+     * @param options.signal Abort signal — aborting stops delivery, signals the responder, and rejects.
+     * @returns Resolves with `{ items }` on completion.
+     */
+    requestStream(topic, data, onItem, options) {
+        const requestTopic = this.getGlobalEventTopic(topic);
+        // Chunks come back on our own namespace so the bridge routes them to us.
+        const { chunkTopic, cancelTopic } = deriveStreamTopics(requestTopic, this.pluginId);
+        const streamId = this.eventBus.generateStreamId();
+        const sessionToken = this.aiModule.session.get() ?? undefined;
+        const timeoutMs = options?.timeoutMs ?? DEFAULT_STREAM_TIMEOUT_MS;
+        const signal = options?.signal;
+        return new Promise((resolve, reject) => {
+            const items = [];
+            let timer = null;
+            let settled = false;
+            const cleanup = () => {
+                settled = true;
+                listener.off();
+                if (timer)
+                    clearTimeout(timer);
+                signal?.removeEventListener('abort', onAbort);
+            };
+            const resetTimer = () => {
+                if (timer)
+                    clearTimeout(timer);
+                timer = setTimeout(() => {
+                    if (settled)
+                        return;
+                    cleanup();
+                    reject(new Error(`Stream timed out after ${timeoutMs}ms with no activity`));
+                }, timeoutMs);
+            };
+            const onAbort = () => {
+                if (settled)
+                    return;
+                cleanup();
+                // Best-effort: tell the responder to stop producing for this stream.
+                this.eventBus.emit(this.pluginId, cancelTopic, { __streamId: streamId });
+                reject(new DOMException('Stream aborted', 'AbortError'));
+            };
+            // Subscribe BEFORE emitting the request so a synchronous responder (federated
+            // in-process bridge) cannot deliver chunks before we are listening.
+            const listener = this.eventBus.on(chunkTopic, ({ data }) => {
+                if (data.__streamId !== streamId || settled)
+                    return; // correlate by streamId
+                resetTimer();
+                if (data.type === 'item') {
+                    items.push(data.payload);
+                    onItem(data.payload);
+                }
+                else if (data.type === 'done') {
+                    cleanup();
+                    resolve({ items });
+                }
+                else if (data.type === 'error') {
+                    cleanup();
+                    reject(new Error(data.error));
+                }
+            });
+            if (signal) {
+                if (signal.aborted) {
+                    onAbort();
+                    return;
+                }
+                signal.addEventListener('abort', onAbort);
+            }
+            resetTimer();
+            // Forward the caller's session token so the responder's AI calls attribute to the
+            // active exercise session (parity with `request`).
+            this.eventBus.emit(this.pluginId, requestTopic, { __streamId: streamId, ...data }, undefined, sessionToken);
+        });
+    }
+    /**
+     * Respond to a streaming request (see `requestStream`). The handler receives the request
+     * message and a `push` function it calls for each item to stream back; when the handler
+     * resolves a `done` is emitted, and if it throws an `error` is emitted instead.
+     *
+     * Mirrors `respond`'s session-token handling so the streamed AI calls inside the handler
+     * are attributed to the requester's session.
+     *
+     * @param topic The streaming request topic to handle.
+     * @param handler Receives the request message and a `push(item)` callback.
+     * @returns An EventListener with an `off()` method for cleanup.
+     */
+    respondStream(topic, handler) {
+        const requestTopic = this.getGlobalEventTopic(topic);
+        // Cancel arrives on our (responder) namespace; chunkTopic is per-request (requester's ns).
+        const { cancelTopic } = deriveStreamTopics(requestTopic, this.pluginId);
+        // Streams the requester aborted — push() becomes a no-op and we skip the final done.
+        const cancelled = new Set();
+        const cancelListener = this.eventBus.on(cancelTopic, ({ data }) => {
+            cancelled.add(data.__streamId);
+        });
+        const requestListener = this.eventBus.on(requestTopic, async (event) => {
+            const streamId = event.data?.__streamId;
+            if (streamId === undefined)
+                return; // not a stream request
+            // Reply on the REQUESTER's namespace (event.sender) so chunks route back to them.
+            const { chunkTopic } = deriveStreamTopics(requestTopic, event.sender);
+            const emitChunk = (chunk) => {
+                this.eventBus.emit(this.pluginId, chunkTopic, chunk);
+            };
+            const previousToken = this.aiModule.session.get();
+            if (event.ai_session_token) {
+                this.aiModule.session.set(event.ai_session_token);
+            }
+            const push = (item) => {
+                if (cancelled.has(streamId))
+                    return;
+                emitChunk({ __streamId: streamId, type: 'item', payload: item });
+            };
+            try {
+                await handler(event, push);
+                if (!cancelled.has(streamId))
+                    emitChunk({ __streamId: streamId, type: 'done' });
+            }
+            catch (err) {
+                if (!cancelled.has(streamId)) {
+                    emitChunk({ __streamId: streamId, type: 'error', error: err instanceof Error ? err.message : String(err) });
+                }
+            }
+            finally {
+                cancelled.delete(streamId);
+                if (event.ai_session_token) {
+                    if (previousToken) {
+                        this.aiModule.session.set(previousToken);
+                    }
+                    else {
+                        this.aiModule.session.clear();
+                    }
+                }
+            }
+        }, 
+        // Ignore our own sender so the responder never reacts to a request it emitted itself.
+        [this.pluginId]);
+        return {
+            off: () => {
+                requestListener.off();
+                cancelListener.off();
+            },
+        };
+    }
     /**
      * Subscribe to an event.
      * @param topic The topic to subscribe to.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rimori/client",
-  "version": "2.5.44",
+  "version": "2.5.45",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "repository": {
@@ -43,7 +43,8 @@
     "globals": "^16.4.0",
     "prettier": "^3.6.2",
     "typescript": "^5.7.2",
-    "typescript-eslint": "^8.46.0"
+    "typescript-eslint": "^8.46.0",
+    "vitest": "^3.2.4"
   },
   "scripts": {
     "sync-db-types": "node ./scripts/sync-db-types.mjs",
@@ -52,6 +53,9 @@
     "build": "tsc",
     "dev": "tsc -w  --preserveWatchOutput",
     "lint": "pnpm exec eslint . --fix",
-    "format": "prettier --write ."
+    "format": "prettier --write .",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:unit": "vitest run"
   }
 }