@rimori/playwright-testing 0.3.5-next.1 → 0.3.5-next.3

package/dist/core/RimoriTestEnvironment.d.ts

@@ -79,6 +79,19 @@ export declare class RimoriTestEnvironment {
      * Removes a one-time mock from the mocks array after it's been used.
      */
     private removeOneTimeMock;
+    /**
+     * Creates a wrapper around the Playwright Request object that provides backwards compatibility
+     * for matchers. The new rimori-client sends `messages` array instead of `instructions`,
+     * so this wrapper extracts the prompts from messages and provides them as `instructions`.
+     *
+     * The old API had a single `instructions` field which typically contained the user's specific
+     * instruction (what the AI should do). The new API splits this into:
+     * - systemPrompt (messages[0] with role='system'): High-level behavior instructions
+     * - userPrompt (messages[1] with role='user'): Specific task instruction
+     *
+     * For backwards compatibility, we concatenate all message contents into `instructions`.
+     */
+    private createBackwardsCompatibleRequest;
     private handleRoute;
     /**
      * Adds a supabase route to the supabase routes object.
@@ -216,21 +229,45 @@ export declare class RimoriTestEnvironment {
         triggerOnMainPanelAction: (payload: MainPanelAction) => Promise<void>;
     };
     readonly ai: {
+        /**
+         * Mocks a text response from the LLM endpoint.
+         * Since getText now uses streamObject internally with a { result: string } schema,
+         * the mock value should be the full response object.
+         *
+         * @param values - The response object to return. Should include { result: string } for getText calls.
+         * @param options - Optional mock options.
+         */
         mockGetText: (values: unknown, options?: MockOptions) => void;
         /**
          * Mocks a streaming text response from the LLM endpoint.
-         * The text will be formatted as SSE (Server-Sent Events) to simulate streaming.
+         * The new rimori-client's getSteamedText uses streamObject internally with { result: string } schema,
+         * so the text is wrapped in a result object.
          *
          * **Note**: Due to Playwright's route.fulfill() requiring a complete response body,
          * all SSE chunks are sent at once (no delays). The client will still parse it as SSE correctly.
          *
-         * @param text - The text to stream. Will be formatted as SSE chunks.
+         * @param text - The text to stream. Will be wrapped as { result: text } and formatted as SSE.
          * @param options - Optional mock options.
          */
         mockGetSteamedText: (text: string, options?: MockOptions) => void;
         mockGetVoice: (values: Buffer, options?: MockOptions) => void;
         mockGetTextFromVoice: (text: string, options?: MockOptions) => void;
+        /**
+         * Mocks an object response from the LLM endpoint.
+         * Since getObject now uses streamObject internally, this is a streaming response.
+         *
+         * @param value - The object to return from the LLM.
+         * @param options - Optional mock options.
+         */
         mockGetObject: (value: Record<string, unknown>, options?: MockOptions) => void;
+        /**
+         * Mocks a streaming object response from the LLM endpoint.
+         * Returns the object via SSE format with data: prefix.
+         *
+         * @param value - The object to stream from the LLM.
+         * @param options - Optional mock options.
+         */
+        mockGetStreamedObject: (value: Record<string, unknown>, options?: MockOptions) => void;
     };
     /**
      * Helpers for tracking browser audio playback in tests.

package/dist/core/RimoriTestEnvironment.js

@@ -47,7 +47,13 @@ class RimoriTestEnvironment {
                 this.addSupabaseRoute('plugin_settings', response, { ...options, method: 'POST' });
             },
             mockGetUserInfo: (userInfo, options) => {
-                this.addSupabaseRoute('/user-info', { ...this.rimoriInfo.profile, ...userInfo }, { ...options, delay: 0 });
+                // Update the rimoriInfo.profile so that MessageChannelSimulator returns the correct user info
+                this.rimoriInfo.profile = { ...this.rimoriInfo.profile, ...userInfo };
+                // Also update the MessageChannelSimulator if it exists (setup() has been called)
+                if (this.messageChannelSimulator) {
+                    this.messageChannelSimulator.setUserInfo(this.rimoriInfo.profile);
+                }
+                this.addSupabaseRoute('/user-info', this.rimoriInfo.profile, { ...options, delay: 0 });
             },
             mockGetPluginInfo: (pluginInfo, options) => {
                 this.addSupabaseRoute('/plugin-info', pluginInfo, options);
@@ -191,23 +197,31 @@ class RimoriTestEnvironment {
             },
         };
         this.ai = {
+            /**
+             * Mocks a text response from the LLM endpoint.
+             * Since getText now uses streamObject internally with a { result: string } schema,
+             * the mock value should be the full response object.
+             *
+             * @param values - The response object to return. Should include { result: string } for getText calls.
+             * @param options - Optional mock options.
+             */
             mockGetText: (values, options) => {
-                console.log('Mocking get text for mockGetText', values, options);
-                console.warn('mockGetText is not tested');
-                this.addBackendRoute('/llm-text', values, options);
+                this.addBackendRoute('/ai/llm', values, { ...options, isStreaming: true });
             },
             /**
              * Mocks a streaming text response from the LLM endpoint.
-             * The text will be formatted as SSE (Server-Sent Events) to simulate streaming.
+             * The new rimori-client's getSteamedText uses streamObject internally with { result: string } schema,
+             * so the text is wrapped in a result object.
              *
              * **Note**: Due to Playwright's route.fulfill() requiring a complete response body,
              * all SSE chunks are sent at once (no delays). The client will still parse it as SSE correctly.
              *
-             * @param text - The text to stream. Will be formatted as SSE chunks.
+             * @param text - The text to stream. Will be wrapped as { result: text } and formatted as SSE.
              * @param options - Optional mock options.
              */
             mockGetSteamedText: (text, options) => {
-                this.addBackendRoute('/ai/llm', text, { ...options, isStreaming: true });
+                // Wrap text in result object as the new client expects { result: string }
+                this.addBackendRoute('/ai/llm', { result: text }, { ...options, isStreaming: true });
             },
             mockGetVoice: (values, options) => {
                 this.addBackendRoute('/voice/tts', values, options);
@@ -215,8 +229,25 @@ class RimoriTestEnvironment {
             mockGetTextFromVoice: (text, options) => {
                 this.addBackendRoute('/voice/stt', text, options);
             },
+            /**
+             * Mocks an object response from the LLM endpoint.
+             * Since getObject now uses streamObject internally, this is a streaming response.
+             *
+             * @param value - The object to return from the LLM.
+             * @param options - Optional mock options.
+             */
             mockGetObject: (value, options) => {
-                this.addBackendRoute('/ai/llm-object', value, { ...options, method: 'POST' });
+                this.addBackendRoute('/ai/llm', value, { ...options, isStreaming: true });
+            },
+            /**
+             * Mocks a streaming object response from the LLM endpoint.
+             * Returns the object via SSE format with data: prefix.
+             *
+             * @param value - The object to stream from the LLM.
+             * @param options - Optional mock options.
+             */
+            mockGetStreamedObject: (value, options) => {
+                this.addBackendRoute('/ai/llm', value, { ...options, isStreaming: true });
             },
         };
         /**
@@ -767,6 +798,53 @@ class RimoriTestEnvironment {
             mocks.splice(index, 1);
         }
     }
+    /**
+     * Creates a wrapper around the Playwright Request object that provides backwards compatibility
+     * for matchers. The new rimori-client sends `messages` array instead of `instructions`,
+     * so this wrapper extracts the prompts from messages and provides them as `instructions`.
+     *
+     * The old API had a single `instructions` field which typically contained the user's specific
+     * instruction (what the AI should do). The new API splits this into:
+     * - systemPrompt (messages[0] with role='system'): High-level behavior instructions
+     * - userPrompt (messages[1] with role='user'): Specific task instruction
+     *
+     * For backwards compatibility, we concatenate all message contents into `instructions`.
+     */
+    createBackwardsCompatibleRequest(originalRequest) {
+        // Create a proxy that intercepts postDataJSON calls
+        return new Proxy(originalRequest, {
+            get(target, prop) {
+                if (prop === 'postDataJSON') {
+                    return () => {
+                        try {
+                            const body = target.postDataJSON();
+                            if (body && body.messages && Array.isArray(body.messages) && !body.instructions) {
+                                // Concatenate all message contents for backwards compatibility
+                                // This allows matchers to check for text that might be in either system or user prompts
+                                const allContent = body.messages
+                                    .map((m) => m.content || '')
+                                    .filter((content) => content.length > 0)
+                                    .join('\n');
+                                if (allContent) {
+                                    return { ...body, instructions: allContent };
+                                }
+                            }
+                            return body;
+                        }
+                        catch {
+                            return null;
+                        }
+                    };
+                }
+                // For all other properties, return the original value bound to the target
+                const value = target[prop];
+                if (typeof value === 'function') {
+                    return value.bind(target);
+                }
+                return value;
+            },
+        });
+    }
     async handleRoute(route, routes) {
         const request = route.request();
         const requestUrl = request.url();
@@ -780,6 +858,8 @@ class RimoriTestEnvironment {
             route.abort('not_found');
             return;
         }
+        // Create backwards-compatible request wrapper for matchers
+        const compatRequest = this.createBackwardsCompatibleRequest(request);
         // Find the first matching mock based on matcher function
         // Priority: mocks with matchers that match > mocks without matchers (as fallback)
         let matchingMock;
@@ -787,7 +867,8 @@ class RimoriTestEnvironment {
         for (const mock of mocks) {
             if (mock.options?.matcher) {
                 try {
-                    if (mock.options.matcher(request)) {
+                    // Use the backwards-compatible request wrapper for matchers
+                    if (mock.options.matcher(compatRequest)) {
                         matchingMock = mock;
                         break;
                     }
@@ -821,10 +902,19 @@ class RimoriTestEnvironment {
         if (typeof matchingMock.value === 'function') {
             responseValue = await matchingMock.value(request);
         }
-        // Handle streaming responses (for mockGetSteamedText)
+        // Handle streaming responses (for mockGetSteamedText and mockGetStreamedObject)
         // Since Playwright requires complete body, we format as SSE without delays
-        if (matchingMock.isStreaming && typeof responseValue === 'string') {
-            const body = this.formatAsSSE(responseValue);
+        if (matchingMock.isStreaming) {
+            let body;
+            if (typeof responseValue === 'string') {
+                // Text streaming (mockGetSteamedText)
+                body = this.formatAsSSE(responseValue);
+            }
+            else {
+                // Object streaming (mockGetStreamedObject)
+                // Format as SSE with JSON payload, followed by [DONE] marker
+                body = `data: ${JSON.stringify(responseValue)}\n\ndata: [DONE]\n\n`;
+            }
             return await route.fulfill({
                 status: 200,
                 headers: { 'Content-Type': 'text/event-stream' },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rimori/playwright-testing",
-  "version": "0.3.5-next.1",
+  "version": "0.3.5-next.3",
   "description": "Playwright testing utilities for Rimori plugins and workers",
   "license": "Apache-2.0",
   "repository": {
@@ -23,11 +23,11 @@
   },
   "peerDependencies": {
     "@playwright/test": "^1.40.0",
-    "@rimori/client": "2.5.10-next.0"
+    "@rimori/client": "2.5.11-next.1"
   },
   "devDependencies": {
     "@playwright/test": "^1.40.0",
-    "@rimori/client": "2.5.10-next.0",
+    "@rimori/client": "2.5.11-next.1",
     "@types/node": "^20.12.7",
     "rimraf": "^5.0.7",
     "typescript": "^5.7.2"