@rimori/playwright-testing 0.3.5-next.2 → 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,44 @@ 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;
     };
     /**

package/dist/core/RimoriTestEnvironment.js

@@ -197,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);
@@ -221,11 +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-object', value, { ...options, isStreaming: true });
+                this.addBackendRoute('/ai/llm', value, { ...options, isStreaming: true });
             },
         };
         /**
@@ -776,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();
@@ -789,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;
@@ -796,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;
                     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rimori/playwright-testing",
-  "version": "0.3.5-next.2",
+  "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"