@chrryai/waffles 1.1.78

package/dist/index.js

@@ -0,0 +1,1764 @@
+'use strict';
+
+var test = require('@playwright/test');
+var path = require('path');
+var process2 = require('process');
+var faker = require('@faker-js/faker');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var path__default = /*#__PURE__*/_interopDefault(path);
+var process2__default = /*#__PURE__*/_interopDefault(process2);
+
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// ../../node_modules/dotenv/package.json
+var require_package = __commonJS({
+  "../../node_modules/dotenv/package.json"(exports, module) {
+    module.exports = {
+      name: "dotenv",
+      version: "16.0.3",
+      description: "Loads environment variables from .env file",
+      main: "lib/main.js",
+      types: "lib/main.d.ts",
+      exports: {
+        ".": {
+          require: "./lib/main.js",
+          types: "./lib/main.d.ts",
+          default: "./lib/main.js"
+        },
+        "./config": "./config.js",
+        "./config.js": "./config.js",
+        "./lib/env-options": "./lib/env-options.js",
+        "./lib/env-options.js": "./lib/env-options.js",
+        "./lib/cli-options": "./lib/cli-options.js",
+        "./lib/cli-options.js": "./lib/cli-options.js",
+        "./package.json": "./package.json"
+      },
+      scripts: {
+        "dts-check": "tsc --project tests/types/tsconfig.json",
+        lint: "standard",
+        "lint-readme": "standard-markdown",
+        pretest: "npm run lint && npm run dts-check",
+        test: "tap tests/*.js --100 -Rspec",
+        prerelease: "npm test",
+        release: "standard-version"
+      },
+      repository: {
+        type: "git",
+        url: "git://github.com/motdotla/dotenv.git"
+      },
+      keywords: [
+        "dotenv",
+        "env",
+        ".env",
+        "environment",
+        "variables",
+        "config",
+        "settings"
+      ],
+      readmeFilename: "README.md",
+      license: "BSD-2-Clause",
+      devDependencies: {
+        "@types/node": "^17.0.9",
+        decache: "^4.6.1",
+        dtslint: "^3.7.0",
+        sinon: "^12.0.1",
+        standard: "^16.0.4",
+        "standard-markdown": "^7.1.0",
+        "standard-version": "^9.3.2",
+        tap: "^15.1.6",
+        tar: "^6.1.11",
+        typescript: "^4.5.4"
+      },
+      engines: {
+        node: ">=12"
+      }
+    };
+  }
+});
+
+// ../../node_modules/dotenv/lib/main.js
+var require_main = __commonJS({
+  "../../node_modules/dotenv/lib/main.js"(exports, module) {
+    var fs = __require("fs");
+    var path2 = __require("path");
+    var os = __require("os");
+    var packageJson = require_package();
+    var version = packageJson.version;
+    var LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/mg;
+    function parse(src) {
+      const obj = {};
+      let lines = src.toString();
+      lines = lines.replace(/\r\n?/mg, "\n");
+      let match;
+      while ((match = LINE.exec(lines)) != null) {
+        const key = match[1];
+        let value = match[2] || "";
+        value = value.trim();
+        const maybeQuote = value[0];
+        value = value.replace(/^(['"`])([\s\S]*)\1$/mg, "$2");
+        if (maybeQuote === '"') {
+          value = value.replace(/\\n/g, "\n");
+          value = value.replace(/\\r/g, "\r");
+        }
+        obj[key] = value;
+      }
+      return obj;
+    }
+    function _log(message) {
+      console.log(`[dotenv@${version}][DEBUG] ${message}`);
+    }
+    function _resolveHome(envPath) {
+      return envPath[0] === "~" ? path2.join(os.homedir(), envPath.slice(1)) : envPath;
+    }
+    function config2(options) {
+      let dotenvPath = path2.resolve(process.cwd(), ".env");
+      let encoding = "utf8";
+      const debug = Boolean(options && options.debug);
+      const override = Boolean(options && options.override);
+      if (options) {
+        if (options.path != null) {
+          dotenvPath = _resolveHome(options.path);
+        }
+        if (options.encoding != null) {
+          encoding = options.encoding;
+        }
+      }
+      try {
+        const parsed = DotenvModule.parse(fs.readFileSync(dotenvPath, { encoding }));
+        Object.keys(parsed).forEach(function(key) {
+          if (!Object.prototype.hasOwnProperty.call(process.env, key)) {
+            process.env[key] = parsed[key];
+          } else {
+            if (override === true) {
+              process.env[key] = parsed[key];
+            }
+            if (debug) {
+              if (override === true) {
+                _log(`"${key}" is already defined in \`process.env\` and WAS overwritten`);
+              } else {
+                _log(`"${key}" is already defined in \`process.env\` and was NOT overwritten`);
+              }
+            }
+          }
+        });
+        return { parsed };
+      } catch (e) {
+        if (debug) {
+          _log(`Failed to load ${dotenvPath} ${e.message}`);
+        }
+        return { error: e };
+      }
+    }
+    var DotenvModule = {
+      config: config2,
+      parse
+    };
+    module.exports.config = DotenvModule.config;
+    module.exports.parse = DotenvModule.parse;
+    module.exports = DotenvModule;
+  }
+});
+
+// src/utils.ts
+var dotenv = __toESM(require_main());
+var TEST_GUEST_FINGERPRINTS = ["052b1051-35e9-4264-97ac-2f0f67761869"];
+var TEST_MEMBER_FINGERPRINTS = [
+  "0493b6d8-80d6-477c-addd-b6b8ccd73e82",
+  "244517e0-2a29-4202-a4fc-facc7ba3ce47",
+  "5bf88c9b-6975-49ae-a5db-74e85ada82d6"
+];
+var TEST_MEMBER_EMAILS = [
+  "feedbackwallet@gmail.com",
+  "diplomatictechno@gmail.com",
+  "localswaphub@gmail.com"
+];
+var VEX_TEST_EMAIL = process.env.VEX_TEST_EMAIL_1;
+var VEX_TEST_PASSWORD = process.env.VEX_TEST_PASSWORD_1;
+var VEX_TEST_FINGERPRINT = TEST_MEMBER_FINGERPRINTS[0];
+var VEX_TEST_EMAIL_2 = process.env.VEX_TEST_EMAIL_2;
+var VEX_TEST_PASSWORD_2 = process.env.VEX_TEST_PASSWORD_2;
+var VEX_TEST_FINGERPRINT_2 = TEST_MEMBER_FINGERPRINTS[1];
+var VEX_TEST_EMAIL_3 = process.env.VEX_TEST_EMAIL_3;
+var VEX_TEST_PASSWORD_3 = process.env.VEX_TEST_PASSWORD_3;
+var VEX_TEST_FINGERPRINT_3 = TEST_MEMBER_FINGERPRINTS[2];
+dotenv.config();
+var TEST_URL = process.env.TEST_URL;
+var LIVE_URL = "https://askvex.com";
+var wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var isCI = process.env.NEXT_PUBLIC_CI || process.env.CI;
+var getURL = ({
+  isLive = false,
+  isMember = false,
+  path: path2 = "",
+  fingerprint = ""
+} = {
+  isLive: false,
+  isMember: false,
+  path: "",
+  fingerprint: ""
+}) => {
+  const base = isLive ? LIVE_URL : TEST_URL;
+  return isMember ? `${base}${path2}?fp=${fingerprint || TEST_MEMBER_FINGERPRINTS[0]}` : `${base}${path2}?fp=${fingerprint || TEST_GUEST_FINGERPRINTS[0]}`;
+};
+var simulateInputPaste = async (page, text) => {
+  await page.evaluate((content) => {
+    const textarea = document.querySelector(
+      'textarea[data-testid="chat-textarea"]'
+    );
+    if (!textarea) return;
+    const pasteEvent = new Event("paste", {
+      bubbles: true,
+      cancelable: true
+    });
+    Object.defineProperty(pasteEvent, "clipboardData", {
+      value: {
+        getData: () => content,
+        types: ["text/plain"],
+        files: [],
+        items: [
+          {
+            kind: "string",
+            type: "text/plain",
+            getAsString: (callback) => callback(content)
+          }
+        ]
+      },
+      writable: false
+    });
+    textarea.dispatchEvent(pasteEvent);
+    textarea.value = content;
+    const inputEvent = new Event("input", { bubbles: true });
+    textarea.dispatchEvent(inputEvent);
+  }, text);
+};
+var simulatePaste = async (page, text) => {
+  await page.evaluate(async (content) => {
+    await navigator.clipboard.writeText(content);
+    const pasteButton = document.querySelector(
+      '[data-testid*="artifacts-paste-button"]'
+    );
+    if (pasteButton) {
+      pasteButton.click();
+    }
+  }, text);
+};
+function capitalizeFirstLetter(val) {
+  return String(val).charAt(0).toUpperCase() + String(val).slice(1);
+}
+var chat = async ({
+  artifacts,
+  page,
+  isMember,
+  isSubscriber,
+  instruction = "This thread will be all about React Native, are you ready?",
+  prompts = [
+    {
+      stop: false,
+      text: "Hello",
+      agentMessageTimeout: 5e5,
+      webSearch: false,
+      delete: true,
+      mix: {
+        image: 0,
+        video: 0,
+        audio: 0,
+        paste: 0,
+        pdf: 0
+      }
+    }
+  ],
+  agentMessageTimeout = 50 * 1e3,
+  isNewChat = true,
+  isLiveTest = false,
+  threadId,
+  creditsConsumed = 0,
+  bookmark = true
+}) => {
+  page.on("console", (msg) => {
+    console.log(`[browser][${msg.type()}] ${msg.text()}`, msg);
+  });
+  if (threadId) {
+    instruction = "";
+  }
+  const hourlyLimit = isSubscriber ? 100 : isMember ? 30 : 10;
+  const getModelCredits = (model) => model === "flux" ? 2 : isMember ? model === "chatGPT" ? 4 : model === "deepSeek" ? 1 : model === "claude" ? 3 : 1 : 1;
+  const MAX_FILE_SIZE = 4;
+  if (prompts?.some(
+    (p) => p.pdf && p.pdf > MAX_FILE_SIZE || p.image && p.image > MAX_FILE_SIZE || p.video && p.video > MAX_FILE_SIZE || p.audio && p.audio > MAX_FILE_SIZE || p.paste && p.paste > MAX_FILE_SIZE || Object.values(p.mix || {}).some((v) => v > MAX_FILE_SIZE)
+  )) {
+    throw new Error("Test file size limit exceeded");
+  }
+  if (isLiveTest) {
+    await page.goto(getURL({ isLive: true, isMember }), {
+      waitUntil: "networkidle"
+    });
+    await wait(3e3);
+  } else if (isNewChat) {
+    await page.goto(getURL({ isLive: false, isMember }), {
+      waitUntil: "networkidle"
+    });
+    await wait(3e3);
+  }
+  let credits = isSubscriber ? 2e3 : (isMember ? 150 : 30) - creditsConsumed;
+  let hourlyUsage = creditsConsumed || 0;
+  const agentModal = page.getByTestId("agent-modal");
+  await test.expect(agentModal).not.toBeVisible();
+  const signInModal = page.getByTestId("sign-in-modal");
+  await test.expect(signInModal).not.toBeVisible();
+  const agentSelectButton = page.getByTestId("agent-select-button");
+  await test.expect(agentSelectButton).toBeVisible();
+  const addDebateAgentButton = page.getByTestId("add-debate-agent-button");
+  await test.expect(addDebateAgentButton).toBeVisible();
+  const getAgentName = async () => {
+    return page.getByTestId("agent-select-button").getAttribute("data-agent-name");
+  };
+  const getDebateAgentName = async () => {
+    return page.getByTestId("add-debate-agent-button").getAttribute("data-agent-name");
+  };
+  !isMember && test.expect(await getAgentName()).toBe("deepSeek");
+  const chatTextarea = page.getByTestId("chat-textarea");
+  await test.expect(chatTextarea).toBeVisible();
+  const creditsInfo = page.getByTestId("credits-info");
+  await test.expect(creditsInfo).toBeVisible();
+  const scrollToBottom = async () => {
+    await page.evaluate(() => {
+      window.scrollTo(0, document.body.scrollHeight);
+    });
+    await wait(500);
+  };
+  const getCreditsLeft = async () => {
+    await scrollToBottom();
+    const creditsInfo2 = page.getByTestId("credits-info");
+    const isCreditsVisible = await creditsInfo2.isVisible().catch(() => false);
+    if (!isCreditsVisible) {
+      return null;
+    }
+    return await creditsInfo2.getAttribute("data-credits-left", {
+      timeout: 1e3
+    });
+  };
+  const getHourlyUsageLeft = async () => {
+    await scrollToBottom();
+    const hourlyLimitInfo = page.getByTestId("hourly-limit-info");
+    return await hourlyLimitInfo.getAttribute("data-hourly-left", {
+      timeout: 1e3
+    });
+  };
+  const subscribeButton = page.getByTestId("subscribe-from-chat-button");
+  await test.expect(subscribeButton).toBeVisible();
+  test.expect(await getCreditsLeft()).toBe(credits.toString());
+  const thread2 = page.getByTestId("thread");
+  let willFail = false;
+  const why = page.getByTestId("instruction-why");
+  let instructionButton = page.getByTestId("instruction-button");
+  let artifactsButton = page.getByTestId("instruction-artifacts-button");
+  if (!threadId) {
+    await test.expect(thread2).not.toBeVisible();
+    await test.expect(why).toBeVisible();
+  } else {
+    await test.expect(instructionButton).not.toBeVisible();
+    instructionButton = page.getByTestId("chat-instruction-button");
+    artifactsButton = page.getByTestId("chat-artifacts-button");
+    await test.expect(thread2).toBeVisible();
+    await test.expect(why).not.toBeVisible();
+  }
+  await test.expect(instructionButton).toBeVisible();
+  const instructionModal = page.getByTestId("instruction-modal");
+  await test.expect(instructionModal).not.toBeVisible();
+  if (instruction) {
+    await instructionButton.click();
+    await test.expect(instructionModal).toBeVisible();
+    const modalMaxCharCount = page.getByTestId(
+      "instruction-modal-max-char-count"
+    );
+    await test.expect(modalMaxCharCount).toBeVisible();
+    const modalTextarea = page.getByTestId("instruction-modal-textarea");
+    await test.expect(modalTextarea).toBeVisible();
+    await modalTextarea.fill(instruction);
+    const modalCharLeft = page.getByTestId("instruction-modal-char-left");
+    await test.expect(modalCharLeft).toBeVisible();
+    await test.expect(modalMaxCharCount).not.toBeVisible();
+    const modalSaveButton = page.getByTestId("instruction-modal-save-button");
+    await test.expect(modalSaveButton).toBeVisible();
+    await modalSaveButton.click();
+  }
+  if (artifacts) {
+    await artifactsButton.click();
+    const dataTestId = threadId ? "chat" : "instruction";
+    await test.expect(instructionModal).toBeVisible();
+    if (artifacts.pdf) {
+      const fileChooserPromise = page.waitForEvent("filechooser");
+      await page.getByTestId(`${dataTestId}-artifacts-upload-button`).click();
+      const testUsedPaths = Array.from({ length: artifacts.pdf }, (_, i) => {
+        const fileType = "pdf";
+        const fileName = `test${capitalizeFirstLetter(fileType)}${i + 1}`;
+        const extension = "pdf";
+        return path__default.default.join(
+          process2__default.default.cwd(),
+          "tests/shared",
+          fileType,
+          `${fileName}.${extension}`
+        );
+      });
+      const fileChooser = await fileChooserPromise;
+      await fileChooser.setFiles(testUsedPaths);
+    }
+    if (artifacts.paste) {
+      for (let i = 0; i < artifacts.paste; i++) {
+        await simulatePaste(page, faker.faker.lorem.sentence({ min: 550, max: 750 }));
+      }
+    }
+    if ((artifacts.pdf || 0) + (artifacts.paste || 0) > 5) {
+      await test.expect(page.getByText("Maximum 5 files allowed")).toBeVisible();
+    }
+    const modalSaveButton = page.getByTestId(`${dataTestId}-modal-save-button`);
+    await test.expect(modalSaveButton).toBeVisible();
+    await modalSaveButton.click();
+    test.expect(await page.getByText("Updated").count()).toBeGreaterThan(0);
+  }
+  const getAgentModalButton = (agent) => {
+    const agentModalButton = page.getByTestId(`agent-modal-button-${agent}`);
+    return agentModalButton;
+  };
+  for (const prompt of prompts) {
+    const debateAgentDeleteButton = page.getByTestId(
+      "debate-agent-delete-button"
+    );
+    const isDebateAgentVisible = await debateAgentDeleteButton.isVisible();
+    if (isDebateAgentVisible) {
+      await debateAgentDeleteButton.click();
+    }
+    if (prompt.model && prompt.model !== await getAgentName()) {
+      await agentSelectButton.click();
+      await test.expect(agentModal).toBeVisible();
+      const agentModalButton = getAgentModalButton(prompt.model);
+      await agentModalButton.click();
+      if (prompt.model === "gemini") {
+        const agentModalCloseButton = page.getByTestId(
+          "agent-modal-close-button"
+        );
+        await test.expect(agentModalCloseButton).toBeVisible();
+        await agentModalCloseButton.click();
+        test.expect(await getAgentName()).toBe(isMember ? "chatGPT" : "flux");
+      } else {
+        if (!isMember) {
+          if (!["flux", "deepSeek", "gemini"].includes(prompt.model)) {
+            await test.expect(signInModal).toBeVisible();
+            const signInModalCloseButton = page.getByTestId(
+              "sign-in-modal-close-button"
+            );
+            await test.expect(signInModalCloseButton).toBeVisible();
+            await signInModalCloseButton.click();
+            test.expect(await getAgentName()).toBe("deepSeek");
+          }
+        } else {
+          test.expect(await getAgentName()).toBe(prompt.model);
+        }
+      }
+    }
+    if (prompt.debateAgent) {
+      {
+        await addDebateAgentButton.click();
+        await test.expect(agentModal).toBeVisible();
+        const geminiButton = page.getByTestId(`agent-modal-button-gemini`);
+        const fluxButton = page.getByTestId(`agent-modal-button-flux`);
+        test.expect(geminiButton).not.toBeVisible();
+        test.expect(fluxButton).not.toBeVisible();
+        const agentModalButton = page.getByTestId(
+          `agent-modal-button-${prompt.debateAgent}`
+        );
+        await agentModalButton.click();
+      }
+      if (!isMember) {
+        test.expect(prompt.shouldFail).toBe(true);
+        willFail = true;
+      } else {
+        test.expect(await getDebateAgentName()).toBe(prompt.debateAgent);
+        await addDebateAgentButton.click();
+        await test.expect(getAgentModalButton(prompt.debateAgent)).not.toBeVisible();
+        const agentModalCloseButton = page.getByTestId(
+          "agent-modal-close-button"
+        );
+        await test.expect(agentModalCloseButton).toBeVisible();
+        await agentModalCloseButton.click();
+        await agentSelectButton.click();
+        await test.expect(agentModal).toBeVisible();
+        const fluxButton = getAgentModalButton("flux");
+        await test.expect(fluxButton).toBeVisible();
+        await fluxButton.click();
+        await wait(1e3);
+        await test.expect(addDebateAgentButton).not.toBeVisible();
+        await agentSelectButton.click();
+        const promptAgentModalButton = page.getByTestId(
+          `agent-modal-button-${prompt.model}`
+        );
+        await promptAgentModalButton.click();
+        test.expect(await getAgentName()).toBe(prompt.model);
+        await addDebateAgentButton.click();
+        await test.expect(addDebateAgentButton).toBeVisible();
+        await getAgentModalButton(prompt.debateAgent).click();
+        test.expect(await getDebateAgentName()).toBe(prompt.debateAgent);
+        test.expect(await getAgentName()).toBe(prompt.model);
+      }
+    }
+    if (willFail) {
+      return;
+    }
+    const attachButton = page.getByTestId("attach-button");
+    const attachButtonClose = page.getByTestId("attach-button-close");
+    const attachButtonImage = page.getByTestId("attach-button-image");
+    const attachButtonVideo = page.getByTestId("attach-button-video");
+    const attachButtonAudio = page.getByTestId("attach-button-audio");
+    const attachButtonPdf = page.getByTestId("attach-button-pdf");
+    if (prompt.image) {
+      for (let i = 0; i < prompt.image; i++) {
+        attachButton.click();
+        await wait(1e3);
+        await test.expect(attachButton).not.toBeVisible();
+        await test.expect(attachButtonClose).toBeVisible();
+        await test.expect(attachButtonImage).toBeVisible();
+        await test.expect(attachButtonVideo).toBeVisible();
+        await test.expect(attachButtonAudio).toBeVisible();
+        await test.expect(attachButtonPdf).toBeVisible();
+        const fileChooserPromise2 = page.waitForEvent("filechooser");
+        if (i === 3) {
+          await test.expect(attachButtonImage).toBeDisabled();
+          await test.expect(attachButtonVideo).toBeDisabled();
+          await test.expect(attachButtonAudio).toBeDisabled();
+          await test.expect(attachButtonPdf).toBeDisabled();
+          await attachButtonClose.click();
+          await test.expect(attachButton).toBeVisible();
+          break;
+        }
+        await attachButtonImage.click();
+        {
+          const fileChooser2 = await fileChooserPromise2;
+          const testUsed = path__default.default.join(
+            process2__default.default.cwd(),
+            `tests/shared/image/testImage${i + 1}.jpeg`
+          );
+          await fileChooser2.setFiles(testUsed);
+          await page.waitForTimeout(2e3);
+          await test.expect(attachButton).toBeVisible();
+          attachButton.click();
+          await test.expect(attachButtonImage).toBeVisible();
+          await test.expect(attachButtonVideo).toBeVisible();
+          await test.expect(attachButtonAudio).toBeVisible();
+          await test.expect(attachButtonPdf).toBeVisible();
+          await attachButtonClose.click();
+          await test.expect(attachButton).toBeVisible();
+        }
+      }
+      const filePreviewClears = page.getByTestId("file-preview-clear");
+      const count = prompt.image > 3 ? 3 : prompt.image;
+      for (let i = 0; i < count; i++) {
+        const filePreviewClear = filePreviewClears.nth(count - i - 1);
+        await test.expect(filePreviewClear).toBeVisible();
+        await filePreviewClear.click();
+        await page.waitForTimeout(500);
+      }
+      await test.expect(attachButton).toBeVisible();
+      attachButton.click();
+      const fileChooserPromise = page.waitForEvent("filechooser");
+      await test.expect(attachButtonImage).toBeVisible();
+      await attachButtonImage.click();
+      const fileChooser = await fileChooserPromise;
+      const testUsedPaths = Array.from(
+        { length: prompt.image },
+        (_, i) => path__default.default.join(
+          process2__default.default.cwd(),
+          "tests/shared/image",
+          `testImage${i + 1}.jpeg`
+        )
+      );
+      await fileChooser.setFiles(testUsedPaths);
+      if (prompt.image > 3) {
+        await test.expect(page.getByText("Too many files selected")).toBeVisible();
+      }
+    } else if (prompt.audio) {
+      for (let i = 0; i < prompt.audio; i++) {
+        attachButton.click();
+        await wait(1e3);
+        await test.expect(attachButton).not.toBeVisible();
+        await test.expect(attachButtonClose).toBeVisible();
+        await test.expect(attachButtonImage).toBeVisible();
+        await test.expect(attachButtonVideo).toBeVisible();
+        await test.expect(attachButtonAudio).toBeVisible();
+        await test.expect(attachButtonPdf).toBeVisible();
+        const fileChooserPromise2 = page.waitForEvent("filechooser");
+        if (i === 3) {
+          await test.expect(attachButtonImage).toBeDisabled();
+          await test.expect(attachButtonVideo).toBeDisabled();
+          await test.expect(attachButtonAudio).toBeDisabled();
+          await test.expect(attachButtonPdf).toBeDisabled();
+          await attachButtonClose.click();
+          await test.expect(attachButton).toBeVisible();
+          break;
+        }
+        await attachButtonAudio.click();
+        {
+          const fileChooser2 = await fileChooserPromise2;
+          const testUsed = path__default.default.join(
+            process2__default.default.cwd(),
+            `tests/shared/audio/testAudio${i + 1}.wav`
+          );
+          await fileChooser2.setFiles(testUsed);
+          await page.waitForTimeout(2e3);
+          await test.expect(attachButton).toBeVisible();
+          attachButton.click();
+          await test.expect(attachButtonImage).toBeVisible();
+          await test.expect(attachButtonVideo).toBeVisible();
+          await test.expect(attachButtonAudio).toBeVisible();
+          await test.expect(attachButtonPdf).toBeVisible();
+          await attachButtonClose.click();
+          await test.expect(attachButton).toBeVisible();
+        }
+      }
+      const filePreviewClears = page.getByTestId("file-preview-clear");
+      const count = prompt.audio > 3 ? 3 : prompt.audio;
+      for (let i = 0; i < count; i++) {
+        const filePreviewClear = filePreviewClears.nth(count - i - 1);
+        await test.expect(filePreviewClear).toBeVisible();
+        await filePreviewClear.click();
+        await page.waitForTimeout(500);
+      }
+      await test.expect(attachButton).toBeVisible();
+      attachButton.click();
+      const fileChooserPromise = page.waitForEvent("filechooser");
+      await test.expect(attachButtonAudio).toBeVisible();
+      await attachButtonAudio.click();
+      const fileChooser = await fileChooserPromise;
+      const testUsedPaths = Array.from(
+        { length: prompt.audio },
+        (_, i) => path__default.default.join(process2__default.default.cwd(), "tests/shared/audio", `testAudio${i + 1}.wav`)
+      );
+      await fileChooser.setFiles(testUsedPaths);
+      if (prompt.audio > 3) {
+        await test.expect(page.getByText("Too many files selected")).toBeVisible();
+      }
+    } else if (prompt.video) {
+      for (let i = 0; i < prompt.video; i++) {
+        attachButton.click();
+        await wait(1e3);
+        await test.expect(attachButton).not.toBeVisible();
+        await test.expect(attachButtonClose).toBeVisible();
+        await test.expect(attachButtonImage).toBeVisible();
+        await test.expect(attachButtonVideo).toBeVisible();
+        await test.expect(attachButtonAudio).toBeVisible();
+        await test.expect(attachButtonPdf).toBeVisible();
+        const fileChooserPromise2 = page.waitForEvent("filechooser");
+        if (i === 3) {
+          await test.expect(attachButtonImage).toBeDisabled();
+          await test.expect(attachButtonVideo).toBeDisabled();
+          await test.expect(attachButtonAudio).toBeDisabled();
+          await test.expect(attachButtonPdf).toBeDisabled();
+          await attachButtonClose.click();
+          await test.expect(attachButton).toBeVisible();
+          break;
+        }
+        await attachButtonAudio.click();
+        {
+          const fileChooser2 = await fileChooserPromise2;
+          const testUsed = path__default.default.join(
+            process2__default.default.cwd(),
+            `tests/shared/video/testVideo${i + 1}.webm`
+          );
+          await fileChooser2.setFiles(testUsed);
+          await page.waitForTimeout(2e3);
+          await test.expect(attachButton).toBeVisible();
+          attachButton.click();
+          await test.expect(attachButtonImage).toBeVisible();
+          await test.expect(attachButtonVideo).toBeVisible();
+          await test.expect(attachButtonAudio).toBeVisible();
+          await test.expect(attachButtonPdf).toBeVisible();
+          await attachButtonClose.click();
+          await test.expect(attachButton).toBeVisible();
+        }
+      }
+      const filePreviewClears = page.getByTestId("file-preview-clear");
+      const count = prompt.video > 3 ? 3 : prompt.video;
+      for (let i = 0; i < count; i++) {
+        const filePreviewClear = filePreviewClears.nth(count - i - 1);
+        await test.expect(filePreviewClear).toBeVisible();
+        await filePreviewClear.click();
+        await page.waitForTimeout(500);
+      }
+      await test.expect(attachButton).toBeVisible();
+      attachButton.click();
+      const fileChooserPromise = page.waitForEvent("filechooser");
+      await test.expect(attachButtonAudio).toBeVisible();
+      await attachButtonAudio.click();
+      const fileChooser = await fileChooserPromise;
+      const testUsedPaths = Array.from(
+        { length: prompt.video },
+        (_, i) => path__default.default.join(
+          process2__default.default.cwd(),
+          "tests/shared/video",
+          `testVideo${i + 1}.webm`
+        )
+      );
+      await fileChooser.setFiles(testUsedPaths);
+      if (prompt.video > 3) {
+        await test.expect(page.getByText("Too many files selected")).toBeVisible();
+      }
+    } else if (prompt.pdf) {
+      for (let i = 0; i < prompt.pdf; i++) {
+        attachButton.click();
+        await wait(1e3);
+        await test.expect(attachButton).not.toBeVisible();
+        await test.expect(attachButtonClose).toBeVisible();
+        await test.expect(attachButtonImage).toBeVisible();
+        await test.expect(attachButtonVideo).toBeVisible();
+        await test.expect(attachButtonAudio).toBeVisible();
+        await test.expect(attachButtonPdf).toBeVisible();
+        const fileChooserPromise2 = page.waitForEvent("filechooser");
+        if (i === 3) {
+          await test.expect(attachButtonImage).toBeDisabled();
+          await test.expect(attachButtonVideo).toBeDisabled();
+          await test.expect(attachButtonAudio).toBeDisabled();
+          await test.expect(attachButtonPdf).toBeDisabled();
+          await attachButtonClose.click();
+          await test.expect(attachButton).toBeVisible();
+          break;
+        }
+        await attachButtonPdf.click();
+        {
+          const fileChooser2 = await fileChooserPromise2;
+          const testUsed = path__default.default.join(
+            process2__default.default.cwd(),
+            `tests/shared/pdf/testPdf${i + 1}.pdf`
+          );
+          await fileChooser2.setFiles(testUsed);
+          await page.waitForTimeout(2e3);
+          await test.expect(attachButton).toBeVisible();
+          attachButton.click();
+          await test.expect(attachButtonImage).toBeVisible();
+          await test.expect(attachButtonVideo).toBeVisible();
+          await test.expect(attachButtonAudio).toBeVisible();
+          await test.expect(attachButtonPdf).toBeVisible();
+          await attachButtonClose.click();
+          await test.expect(attachButton).toBeVisible();
+        }
+      }
+      const filePreviewClears = page.getByTestId("file-preview-clear");
+      const count = prompt.pdf > 3 ? 3 : prompt.pdf;
+      for (let i = 0; i < count; i++) {
+        const filePreviewClear = filePreviewClears.nth(count - i - 1);
+        await test.expect(filePreviewClear).toBeVisible();
+        await filePreviewClear.click();
+        await page.waitForTimeout(500);
+      }
+      await test.expect(attachButton).toBeVisible();
+      attachButton.click();
+      const fileChooserPromise = page.waitForEvent("filechooser");
+      await test.expect(attachButtonPdf).toBeVisible();
+      await attachButtonPdf.click();
+      const fileChooser = await fileChooserPromise;
+      const testUsedPaths = Array.from(
+        { length: prompt.pdf },
+        (_, i) => path__default.default.join(process2__default.default.cwd(), "tests/shared/pdf", `testPdf${i + 1}.pdf`)
+      );
+      await fileChooser.setFiles(testUsedPaths);
+      if (prompt.pdf > 3) {
+        await test.expect(page.getByText("Too many files selected")).toBeVisible();
+      }
+    } else if (prompt.paste) {
+      const filePreviewClears = page.getByTestId("file-preview-clear");
+      const count = prompt.paste > 3 ? 3 : prompt.paste;
+      for (let i = 0; i < prompt.paste; i++) {
+        const text = faker.faker.lorem.sentence({ min: 550, max: 750 });
+        await simulateInputPaste(page, text);
+        await page.waitForTimeout(1e3);
+      }
+      if (prompt.paste > 3) {
+        await test.expect(page.getByText("Too many files")).toBeVisible();
+      }
+      for (let i = 0; i < count; i++) {
+        const filePreviewClear = filePreviewClears.nth(count - i - 1);
+        await test.expect(filePreviewClear).toBeVisible();
+        await filePreviewClear.click();
+        await page.waitForTimeout(500);
+      }
+      for (let i = 0; i < count; i++) {
+        const text = faker.faker.lorem.sentence({ min: 550, max: 750 });
+        await simulateInputPaste(page, text);
+      }
+    } else if (prompt.mix) {
+      const fileExtensions = {
+        image: "jpeg",
+        video: "mp4",
+        audio: "wav",
+        pdf: "pdf"
+      };
+      const size = Object.values(prompt.mix).reduce((a, b) => a + b);
+      const to = size > 3 ? 3 : size;
+      let filesToAttach = [];
+      let filesToPaste = 0;
+      for (const [key, count] of Object.entries(prompt.mix)) {
+        if (key === "paste") {
+          filesToPaste = count;
+        } else {
+          for (let i = 0; i < count; i++) {
+            filesToAttach.push(key);
+          }
+        }
+      }
+      filesToAttach = filesToAttach.slice(0, 3 - filesToPaste);
+      for (let i = 0; i < filesToPaste; i++) {
+        const text = faker.faker.lorem.sentence({ min: 550, max: 750 });
+        await simulateInputPaste(page, text);
+        await page.waitForTimeout(1e3);
+      }
+      for (let i = 0; i < filesToAttach.length; i++) {
+        const key = filesToAttach[i];
+        if (!key) break;
+        attachButton.click();
+        await wait(1e3);
+        await test.expect(attachButton).not.toBeVisible();
+        await test.expect(attachButtonClose).toBeVisible();
+        await test.expect(attachButtonImage).toBeVisible();
+        await test.expect(attachButtonVideo).toBeVisible();
+        await test.expect(attachButtonAudio).toBeVisible();
+        await test.expect(attachButtonPdf).toBeVisible();
+        if (i > to) {
+          await test.expect(attachButtonImage).toBeDisabled();
+          await test.expect(attachButtonVideo).toBeDisabled();
+          await test.expect(attachButtonAudio).toBeDisabled();
+          await test.expect(attachButtonPdf).toBeDisabled();
+          await attachButtonClose.click();
+          await test.expect(attachButton).toBeVisible();
+          break;
+        }
+        const fileChooserPromise = page.waitForEvent("filechooser");
+        if (key === "audio") {
+          await test.expect(attachButtonAudio).toBeVisible();
+          await attachButtonAudio.click();
+        } else if (key === "image") {
+          await test.expect(attachButtonImage).toBeVisible();
+          await attachButtonImage.click();
+        } else if (key === "video") {
+          await test.expect(attachButtonVideo).toBeVisible();
+          await attachButtonVideo.click();
+        } else if (key === "pdf") {
+          await test.expect(attachButtonPdf).toBeVisible();
+          await attachButtonPdf.click();
+        }
+        {
+          const fileChooser = await fileChooserPromise;
+          const extension = fileExtensions[key] || "jpeg";
+          const fileIndex = filesToAttach.slice(0, i + 1).filter((k) => k === key).length;
+          const testUsed = path__default.default.join(
+            process2__default.default.cwd(),
+            `tests/shared/${key}/test${capitalizeFirstLetter(key)}${fileIndex}.${extension}`
+          );
+          await fileChooser.setFiles(testUsed);
+          await page.waitForTimeout(2e3);
+          await test.expect(attachButton).toBeVisible();
+          attachButton.click();
+          await test.expect(attachButtonImage).toBeVisible();
+          await test.expect(attachButtonVideo).toBeVisible();
+          await test.expect(attachButtonAudio).toBeVisible();
+          await test.expect(attachButtonPdf).toBeVisible();
+          await attachButtonClose.click();
+          await test.expect(attachButton).toBeVisible();
+        }
+      }
+      const filePreviewClears = page.getByTestId("file-preview-clear");
+      for (let i = 0; i < to; i++) {
+        const filePreviewClear = filePreviewClears.nth(0);
+        await test.expect(filePreviewClear).toBeVisible();
+        await filePreviewClear.click();
+        await page.waitForTimeout(500);
+      }
+      for (let i = 0; i < filesToPaste; i++) {
+        const text = faker.faker.lorem.sentence({ min: 550, max: 750 });
+        await simulateInputPaste(page, text);
+        await page.waitForTimeout(1e3);
+      }
+      if (filesToAttach.length > 0) {
+        await test.expect(attachButton).toBeVisible();
+        attachButton.click();
+        const fileChooserPromise = page.waitForEvent("filechooser");
+        const key = filesToAttach[0];
+        if (key === "image") {
+          await attachButtonImage.click();
+        } else if (key === "video") {
+          await attachButtonVideo.click();
+        } else if (key === "audio") {
+          await attachButtonAudio.click();
+        } else if (key === "pdf") {
+          await attachButtonPdf.click();
+        }
+        const fileChooser = await fileChooserPromise;
+        const testUsedPaths = await Promise.all(
+          Array.from({ length: filesToAttach.length }, async (_, i) => {
+            const fileType = filesToAttach[i];
+            if (!fileType) {
+              return null;
+            }
+            const fileName = `test${capitalizeFirstLetter(fileType)}${i + 1}`;
+            const extension = fileExtensions[fileType] || "jpeg";
+            return path__default.default.join(
+              process2__default.default.cwd(),
+              "tests/shared",
+              fileType,
+              `${fileName}.${extension}`
+            );
+          })
+        );
+        await fileChooser.setFiles(
+          testUsedPaths.filter((path2) => path2 !== null)
+        );
+        if (filesToAttach.length + filesToPaste > 3) {
+          await test.expect(page.getByText("Too many files selected")).toBeVisible();
+        }
+      }
+    }
+    await chatTextarea.fill(prompt.text);
+    if (prompt.webSearch) {
+      const webSearchButton = page.getByTestId("web-search-button-disabled");
+      await test.expect(webSearchButton).toBeVisible();
+      await webSearchButton.click();
+      if (!isMember) {
+        await test.expect(agentModal).toBeVisible();
+        const agentModalCloseButton = page.getByTestId(
+          "agent-modal-close-button"
+        );
+        await test.expect(agentModalCloseButton).toBeVisible();
+        await agentModalCloseButton.click();
+      }
+    }
+    const sendButton = page.getByTestId("chat-send-button");
+    await test.expect(sendButton).toBeVisible();
+    if (prompt.shouldFail) {
+      console.log(
+        `\u{1F6AB} Testing hourly limit boundary with message: "${prompt.text}"`
+      );
+      await test.expect(sendButton).toBeDisabled();
+      break;
+    }
+    await scrollToBottom();
+    await sendButton.click();
+    if (prompts.indexOf(prompt) === 0 && artifacts) {
+      await test.expect(page.getByText("Uploading artifacts...")).toBeVisible();
+    }
+    await page.waitForTimeout(5e3);
+    const stopButton = page.getByTestId("chat-stop-streaming-button");
+    await test.expect(stopButton).toBeVisible({
+      timeout: prompt.agentMessageTimeout || agentMessageTimeout
+    });
+    const getLastMessage = async () => {
+      await page.waitForFunction(
+        () => {
+          const userMessages2 = document.querySelectorAll(
+            '[data-testid="user-message"]'
+          );
+          const guestMessages2 = document.querySelectorAll(
+            '[data-testid="guest-message"]'
+          );
+          console.log(
+            `Debug: Found ${userMessages2.length} user messages, ${guestMessages2.length} guest messages`
+          );
+          return userMessages2.length > 0 || guestMessages2.length > 0;
+        },
+        { timeout: 1e4 }
+      );
+      const userMessages = page.getByTestId("user-message");
+      const guestMessages = page.getByTestId("guest-message");
+      const userCount = await userMessages.count();
+      const guestCount = await guestMessages.count();
+      console.log(
+        `Debug: After wait - ${userCount} user messages, ${guestCount} guest messages`
+      );
+      if (userCount > 0) {
+        console.log(`Debug: Using user message (${userCount} found)`);
+        return userMessages.nth(userCount - 1);
+      } else if (guestCount > 0) {
+        console.log(`Debug: Using guest message (${guestCount} found)`);
+        return guestMessages.nth(guestCount - 1);
+      } else {
+        throw new Error("No user or guest messages found after waiting");
+      }
+    };
+    await test.expect(await getLastMessage()).toBeVisible({
+      timeout: prompt.agentMessageTimeout || agentMessageTimeout
+    });
+    const lastMessage = await getLastMessage();
+    console.log(`Debug: Got last message, looking for delete button...`);
+    if (prompt.stop) {
+      await stopButton.click();
+      await test.expect(stopButton).not.toBeVisible({
+        timeout: 8e3
+      });
+      prompt.model && (credits -= getModelCredits(prompt.model));
+    } else {
+      hourlyUsage += 1 + (prompt.debateAgent ? 1 : 0);
+    }
+    const deleteMessageButton = lastMessage.locator(
+      "[data-testid=delete-message]"
+    );
+    const deleteButtonCount = await deleteMessageButton.count();
+    console.log(
+      `Debug: Found ${deleteButtonCount} delete buttons in last message`
+    );
+    const userMessageContent = (await getLastMessage()).getByText(prompt.text);
+    await test.expect(userMessageContent).toBeVisible({
+      timeout: agentMessageTimeout
+    });
+    const getLastAgentMessage = async () => {
+      const agentMessages = page.getByTestId("agent-message");
+      const messageCount = await agentMessages.count();
+      return agentMessages.nth(messageCount - 1);
+    };
+    const getLastUserMessage = async () => {
+      const userMessages = page.getByTestId(
+        `${isMember ? "user" : "guest"}-message`
+      );
+      const messageCount = await userMessages.count();
+      return userMessages.nth(messageCount - 1);
+    };
+    await test.expect(await getLastAgentMessage()).toBeVisible();
+    const deleteAgentMessageButton = (await getLastAgentMessage()).locator(
+      "[data-testid=delete-message]"
+    );
+    await test.expect(deleteAgentMessageButton).toBeVisible({
+      timeout: prompt.agentMessageTimeout || agentMessageTimeout,
+      visible: !prompt.stop
+    });
+    if (prompt.image) {
+      const userMessageImageCount = await (await getLastUserMessage()).getByTestId("user-message-image").count();
+      test.expect(userMessageImageCount).toBe(prompt.image > 3 ? 3 : prompt.image);
+    } else if (prompt.mix?.image) {
+      const userMessageImageCount = await (await getLastUserMessage()).getByTestId("user-message-image").count();
+      test.expect(userMessageImageCount).toBe(
+        prompt.mix.image > 3 ? 3 : prompt.mix.image
+      );
+    } else if (prompt.video) {
+      const userMessageVideoCount = await (await getLastUserMessage()).getByTestId("user-message-video").count();
+      test.expect(userMessageVideoCount).toBe(prompt.video > 3 ? 3 : prompt.video);
+    } else if (prompt.mix?.video) {
+      const userMessageVideoCount = (await getLastUserMessage()).getByTestId("user-message-video").count();
+      test.expect(userMessageVideoCount).toBe(
+        prompt.mix.video > 3 ? 3 : prompt.mix.video
+      );
+    } else if (prompt.audio) {
+      const userMessageAudioCount = await (await getLastUserMessage()).getByTestId("user-message-audio").count();
+      test.expect(userMessageAudioCount).toBe(prompt.audio > 3 ? 3 : prompt.audio);
+    } else if (prompt.mix?.audio) {
+      const userMessageAudioCount = (await getLastUserMessage()).getByTestId("user-message-audio").count();
+      test.expect(userMessageAudioCount).toBe(
+        prompt.mix.audio > 3 ? 3 : prompt.mix.audio
+      );
+    } else if (prompt.pdf) {
+      const userMessagePdfCount = await (await getLastUserMessage()).getByTestId("user-message-pdf").count();
+      test.expect(userMessagePdfCount).toBe(prompt.pdf > 3 ? 3 : prompt.pdf);
+    } else if (prompt.mix?.pdf) {
+      const userMessagePdfCount = await (await getLastUserMessage()).getByTestId("user-message-pdf").count();
+      test.expect(userMessagePdfCount).toBe(prompt.mix.pdf > 3 ? 3 : prompt.mix.pdf);
+    }
+    if (prompt.webSearch) {
+      const webSearchResults = (await getLastAgentMessage()).getByTestId(
+        "web-search-results"
+      );
+      await test.expect(webSearchResults).toBeVisible({
+        timeout: prompt.agentMessageTimeout || agentMessageTimeout
+      });
+      const webSearchResult = webSearchResults.getByTestId("web-search-result");
+      test.expect(await webSearchResult.count()).toBe(4);
+    }
+    await wait(1e3);
+    const threadUrl = page.url();
+    const threadId2 = threadUrl.split("/threads/")[1]?.split("?")[0];
+    test.expect(threadId2).toBeTruthy();
+    console.log("Thread:", threadId2);
+    const likeButton = (await getLastAgentMessage()).locator(
+      "[data-testid=like-button]"
+    );
+    if (prompts.indexOf(prompt) === 0 && artifacts) {
+      const dataTestId = threadId2 ? "chat" : "instruction";
+      let artifactsButton2 = page.getByTestId(
+        `${dataTestId}-instruction-artifacts-button`
+      );
+      await artifactsButton2.click();
+      const instructionModal2 = page.getByTestId(
+        `${dataTestId}-instruction-modal`
+      );
+      await test.expect(instructionModal2).toBeVisible();
+      const filePreviewClears = page.getByTestId(
+        `${dataTestId}-instruction-file-preview-clear`
+      );
+      let count = (artifacts.pdf || 0) + (artifacts.paste || 0);
+      if (count > 5) {
+        count = 5;
+      }
+      for (let i = 0; i < count; i++) {
+        const filePreviewClear = filePreviewClears.nth(count - i - 1);
+        await test.expect(filePreviewClear).toBeVisible();
+        await filePreviewClear.click();
+        await page.waitForTimeout(1e3);
+      }
+      test.expect(await filePreviewClears.count()).toBe(0);
+      if (artifacts.paste) {
+        for (let i = 0; i < artifacts.paste; i++) {
+          await simulatePaste(
+            page,
+            faker.faker.lorem.sentence({ min: 550, max: 750 })
+          );
+        }
+      }
+      if (artifacts.pdf) {
+        const fileChooserPromise = page.waitForEvent("filechooser");
+        await page.getByTestId(`${dataTestId}-instruction-artifacts-upload-button`).click();
+        const testUsedPaths = Array.from({ length: artifacts.pdf }, (_, i) => {
+          const fileType = "pdf";
+          const fileName = `test${capitalizeFirstLetter(fileType)}${i + 1}`;
+          const extension = "pdf";
+          return path__default.default.join(
+            process2__default.default.cwd(),
+            "tests/shared",
+            fileType,
+            `${fileName}.${extension}`
+          );
+        });
+        const fileChooser = await fileChooserPromise;
+        await fileChooser.setFiles(testUsedPaths);
+      }
+      if ((artifacts.pdf || 0) + (artifacts.paste || 0) > 5) {
+        await test.expect(page.getByText("Maximum 5 files allowed")).toBeVisible();
+      }
+      const modalSaveButton = page.getByTestId(
+        `${dataTestId}-instruction-modal-save-button`
+      );
+      await test.expect(modalSaveButton).toBeVisible();
+      await modalSaveButton.click();
+      await wait(1e4);
+      const modalCloseButton = page.getByTestId(
+        `${dataTestId}-instruction-modal-close-button`
+      );
+      await test.expect(modalCloseButton).toBeVisible();
+      await modalCloseButton.click();
+    }
+    if (!prompt.stop) {
+      await test.expect(likeButton).toBeVisible({
+        timeout: prompt.agentMessageTimeout || agentMessageTimeout
+      });
+      const dislikeButton = (await getLastAgentMessage()).locator(
+        "[data-testid=dislike-button]"
+      );
+      await test.expect(dislikeButton).toBeVisible({
+        timeout: prompt.agentMessageTimeout || agentMessageTimeout
+      });
+      const getFilterLikedButton = ({ liked }) => page.getByTestId(`${liked ? "unfilter" : "filter"}-liked-button`);
+      await test.expect(getFilterLikedButton({ liked: false })).toBeVisible({
+        timeout: 1e4
+      });
+      if (prompt.like) {
+        await getFilterLikedButton({ liked: false }).click();
+        await test.expect(await getLastAgentMessage()).not.toBeVisible({
+          timeout: 8e3
+        });
+        await getFilterLikedButton({ liked: true }).click();
+        await test.expect(await getLastAgentMessage()).toBeVisible({
+          timeout: 8e3
+        });
+        await likeButton.click();
+        await wait(4e3);
+        await getFilterLikedButton({ liked: false }).click();
+        const unlikeButton = (await getLastAgentMessage()).locator(
+          "[data-testid=unlike-button]"
+        );
+        await test.expect(unlikeButton).toBeVisible({
+          timeout: 8e3
+        });
+        await unlikeButton.click();
+        await test.expect(await getLastAgentMessage()).not.toBeVisible({
+          timeout: 8e3
+        });
+        await getFilterLikedButton({ liked: true }).click();
+        await test.expect(await getLastAgentMessage()).toBeVisible({
+          timeout: 8e3
+        });
+        await getFilterLikedButton({ liked: false }).click();
+        await test.expect(await getLastAgentMessage()).not.toBeVisible({
+          timeout: 8e3
+        });
+        await getFilterLikedButton({ liked: true }).click();
+        await wait(4e3);
+      }
+      if (prompt.model) {
+        credits -= getModelCredits(prompt.model);
+        if (prompt.debateAgent) {
+          credits -= getModelCredits(prompt.debateAgent);
+        }
+      }
+      page.getByTestId("hourly-limit-info");
+      if (hourlyLimit - hourlyUsage === 0) {
+        willFail = true;
+        return;
+      }
+      const hourlyUsageLeft = await getHourlyUsageLeft();
+      test.expect(hourlyUsageLeft).toBe((hourlyLimit - hourlyUsage).toString());
+      const creditsLeft = await getCreditsLeft();
+      if (creditsLeft !== null) {
+        test.expect(creditsLeft).toBe(credits.toString());
+        console.log(
+          `\u2705 Credits assertion: ${creditsLeft} left (expected: ${credits})`
+        );
+      }
+      if (prompt.model === "flux") {
+        const imageGenerationButton = page.getByTestId(
+          "image-generation-button"
+        );
+        await imageGenerationButton.click();
+        await test.expect.poll(getAgentName, { timeout: 5e3 }).not.toBe("flux");
+        const expectedDefaultAgent = !isMember ? "deepSeek" : "chatGPT";
+        test.expect(await getAgentName()).toBe(expectedDefaultAgent);
+        await imageGenerationButton.click();
+        await test.expect.poll(getAgentName, { timeout: 5e3 }).toBe("flux");
+        await imageGenerationButton.click();
+        await page.waitForTimeout(2e3);
+        test.expect(await getAgentName()).toBe(!isMember ? "deepSeek" : "chatGPT");
+      }
+    }
+    if (prompt.delete) {
+      await deleteMessageButton.click();
+      await wait(200);
+      await deleteMessageButton.click();
+      await wait(4e3);
+      await test.expect(deleteMessageButton).not.toBeVisible();
+    }
+  }
+  const getNthMenuThread = async (nth) => {
+    const threads = page.getByTestId("menu-thread-item");
+    await threads.count();
+    return threads.nth(nth);
+  };
+  const getFirstMenuThread = async () => {
+    return getNthMenuThread(0);
+  };
+  if (bookmark) {
+    (await getFirstMenuThread()).hover();
+    const bookmarkButton = page.getByTestId("thread-not-bookmarked");
+    await test.expect(bookmarkButton).toBeVisible();
+    await bookmarkButton.click();
+    const menuBookmarked = page.getByTestId("menu-bookmarked");
+    await test.expect(menuBookmarked).toBeVisible({
+      timeout: 1e4
+    });
+    await menuBookmarked.click();
+    const threadNotBookmarked = page.getByTestId("thread-not-bookmarked");
+    await test.expect(threadNotBookmarked).toBeVisible({
+      timeout: 1e4
+    });
+    (await getFirstMenuThread()).hover();
+    const menuNotBookmarked = page.getByTestId("menu-not-bookmarked");
+    await test.expect(menuNotBookmarked).toBeVisible();
+    await threadNotBookmarked.click();
+    await wait(2e3);
+  }
+  if (isNewChat) {
+    await page.getByTestId("new-chat-button").click();
+    await wait(5e3);
+    await test.expect(
+      isMember ? page.getByTestId("user-message") : page.getByTestId("guest-message")
+    ).not.toBeVisible({
+      timeout: 5e3
+    });
+  }
+};
+var signIn = async ({
+  page,
+  isOpened = false,
+  signOut = false,
+  register = false,
+  email = process.env.VEX_TEST_EMAIL_2,
+  password = process.env.VEX_TEST_PASSWORD_2
+}) => {
+  const signInButton = page.getByTestId("login-button");
+  if (!isOpened) {
+    await test.expect(signInButton).toBeVisible({
+      timeout: 15e3
+    });
+    await signInButton.click();
+  }
+  page.url().includes("extension");
+  const modal = page.getByTestId("sign-in-modal");
+  await test.expect(modal).toBeVisible();
+  const emailInput = page.getByTestId("sign-in-email");
+  await test.expect(emailInput).toBeVisible();
+  await emailInput.fill(email);
+  const passwordInput = page.getByTestId("sign-in-password");
+  await test.expect(passwordInput).toBeVisible();
+  await passwordInput.fill(password);
+  await wait(2e3);
+  const signInSubmit = page.getByTestId("login-submit");
+  await test.expect(signInSubmit).toBeVisible();
+  await signInSubmit.click({
+    force: true
+  });
+  if (!!process.env.CI) {
+    await page.waitForFunction(
+      () => {
+        const submitButton = document.querySelector(
+          '[data-testid="login-submit"]'
+        );
+        return submitButton && submitButton.hasAttribute("data-redirect-url");
+      },
+      { timeout: 15e3 }
+    );
+    const redirectUrl = await signInSubmit.getAttribute("data-redirect-url");
+    if (!redirectUrl) {
+      throw new Error("Redirect URL not found");
+    }
+    await page.goto(redirectUrl);
+  }
+  await wait(4e3);
+  await test.expect(signInButton).not.toBeVisible();
+  const accountButton = page.getByTestId("account-button");
+  await test.expect(accountButton).toBeVisible();
+  if (signOut) {
+    await accountButton.click();
+    const email2 = page.getByTestId("account-email");
+    await test.expect(email2).toBeVisible();
+    const logoutButton = page.getByTestId("account-logout-button");
+    await test.expect(logoutButton).toBeVisible();
+    await logoutButton.click();
+    await test.expect(signInButton).toBeVisible({
+      timeout: 15e3
+    });
+  }
+};
+
+// src/collaboration.ts
+async function collaboration({
+  page,
+  isLive = false,
+  isMember = false,
+  browser,
+  withShareLink = true,
+  fingerprint,
+  collaborate = "feedbackwallet@gmail.com"
+}) {
+  const TEST_URL2 = getURL({
+    fingerprint,
+    isLive,
+    isMember
+  });
+  const getMemberUrl = (path2) => getURL({
+    isLive,
+    isMember: true,
+    path: path2
+  });
+  const context1 = await browser.newContext();
+  const page1 = page;
+  await page1.goto(TEST_URL2, { waitUntil: "networkidle" });
+  await chat({
+    bookmark: false,
+    page: page1,
+    isNewChat: false,
+    isMember,
+    instruction: "Let's plan a trip together",
+    prompts: [
+      {
+        text: "I want to visit Japan. What should I know?",
+        model: "deepSeek"
+      }
+    ]
+  });
+  await page1.waitForTimeout(2e3);
+  const threadUrl = page1.url();
+  const threadId = threadUrl.split("/threads/")[1]?.split("?")[0];
+  test.expect(threadId).toBeTruthy();
+  console.log("Thread:", threadId);
+  const threadShareButton = page1.getByTestId("thread-share-button");
+  test.expect(threadShareButton).toBeVisible();
+  const chatShareButton = page1.getByTestId("chat-share-button");
+  await chatShareButton.click();
+  await wait(1e3);
+  const chatCollaborateButton = page1.getByTestId("chat-collaborate-button");
+  test.expect(chatCollaborateButton).toBeVisible();
+  await chatCollaborateButton.click();
+  await wait(1e3);
+  const shareInput = page1.getByTestId("chat-share-input");
+  await test.expect(shareInput).toHaveValue(threadUrl);
+  const shareCopyButton = page1.getByTestId("chat-share-copy-button");
+  test.expect(shareCopyButton).toBeVisible();
+  await shareCopyButton.click();
+  await wait(1e3);
+  const collaborateInput = page1.getByTestId("chat-collaborate-input");
+  test.expect(collaborateInput).toBeVisible();
+  await collaborateInput.fill("iliyan@chrry.ai");
+  const collaborateAddButton = page1.getByTestId("chat-collaborate-add-button");
+  await collaborateAddButton.click();
+  const collaborateName = page1.getByTestId("chat-collaborator-name");
+  await test.expect(collaborateName).toBeVisible({
+    timeout: 8e3
+  });
+  const collaborateEmail = page1.getByTestId("chat-collaborator-email");
+  await test.expect(collaborateEmail).toBeVisible();
+  const collaborateStatus = page1.getByTestId("chat-collaborator-status");
+  await test.expect(collaborateStatus).toHaveText("pending");
+  const collaboratorRevokeButton = page1.getByTestId(
+    "chat-collaborator-revoke-button"
+  );
+  await test.expect(collaboratorRevokeButton).toBeVisible();
+  await collaboratorRevokeButton.click();
+  await wait(1e3);
+  await collaboratorRevokeButton.click();
+  await wait(1e3);
+  await test.expect(collaborateName).not.toBeVisible({
+    timeout: 8e3
+  });
+  await test.expect(collaborateEmail).not.toBeVisible();
+  await collaborateInput.fill(collaborate);
+  await collaborateAddButton.click();
+  await test.expect(collaborateName).toBeVisible({
+    timeout: 8e3
+  });
+  await test.expect(collaborateEmail).toBeVisible();
+  await test.expect(collaborateStatus).toHaveText("pending");
+  await page1.getByTestId("chat-share-modal-close-button").click();
+  await wait(1e3);
+  const chatInput1 = page1.getByTestId("chat-textarea");
+  const context2 = await browser.newContext();
+  const page2 = await context2.newPage();
+  await page2.goto(getMemberUrl(), {
+    waitUntil: "networkidle"
+  });
+  await signIn({ page: page2 });
+  await page2.goto(
+    withShareLink ? `${getMemberUrl(`/threads/${threadId}`)}` : getMemberUrl(),
+    {
+      waitUntil: "networkidle"
+    }
+  );
+  const chatInput2 = page2.getByTestId("chat-textarea");
+  await test.expect(chatInput2).toBeDisabled();
+  const acceptCollaborationButton = page2.getByTestId(
+    "chat-accept-collaboration"
+  );
+  test.expect(acceptCollaborationButton).toBeVisible();
+  const rejectCollaborationButton = page2.getByTestId(
+    "chat-reject-collaboration"
+  );
+  test.expect(rejectCollaborationButton).toBeVisible();
+  await acceptCollaborationButton.click();
+  await test.expect(chatInput2).toBeEnabled({
+    timeout: 8e3
+  });
+  await chat({
+    page: page2,
+    isNewChat: false,
+    threadId,
+    isMember: true,
+    // Member user (signed in)
+    prompts: [
+      {
+        text: "I've been to Tokyo before! The cherry blossoms are amazing in spring.",
+        model: "deepSeek"
+      }
+    ]
+  });
+  await page1.bringToFront();
+  await page1.waitForTimeout(3e3);
+  const messages1 = page1.getByTestId("message");
+  const count1 = await messages1.count();
+  test.expect(count1).toBeGreaterThanOrEqual(3);
+  await chat({
+    page: page1,
+    isNewChat: false,
+    threadId,
+    isMember,
+    creditsConsumed: 1,
+    prompts: [
+      {
+        text: "That's great! When is the best time to see cherry blossoms?",
+        model: "deepSeek"
+      }
+    ]
+  });
+  await page2.bringToFront();
+  await page2.waitForTimeout(3e3);
+  const messages2 = page2.getByTestId("message");
+  const count2 = await messages2.count();
+  test.expect(count2).toBeGreaterThanOrEqual(5);
+  await page1.bringToFront();
+  await chatInput1.click();
+  await chatInput1.fill("I'm typing...");
+  await page2.bringToFront();
+  await page2.waitForTimeout(2e3);
+  test.expect(
+    await page2.getByTestId("typing-indicator").count()
+  ).toBeGreaterThanOrEqual(1);
+  await page2.waitForTimeout(5e3);
+  test.expect(await page2.getByTestId("typing-indicator").count()).toBe(0);
+  await chatInput2.click();
+  await chatInput2.fill("I'm typing too...");
+  await page1.bringToFront();
+  await page1.waitForTimeout(2e3);
+  test.expect(
+    await page1.getByTestId("typing-indicator").count()
+  ).toBeGreaterThanOrEqual(1);
+  await page1.waitForTimeout(3e3);
+  test.expect(await page1.getByTestId("typing-indicator").count()).toBe(0);
+  await context1.close();
+  await context2.close();
+}
+var limit = async ({
+  page,
+  isMember,
+  isSubscriber
+}) => {
+  const hourlyLimit = isSubscriber ? 100 : isMember ? 30 : 10;
+  console.log(
+    `\u{1F3AF} Testing hourly limit: ${hourlyLimit} requests for ${isMember ? "member" : "guest"}`
+  );
+  const limitPrompts = Array.from({ length: hourlyLimit }, (_, i) => {
+    const isFluxMessage = i % (isMember ? 5 : 3) === 0;
+    const isClaudeMessage = isMember && i % 5 === 0;
+    const isChatGPTMessage = isMember && i % 3 === 0;
+    const isWebSearch = (isClaudeMessage || isChatGPTMessage) && !isFluxMessage && i % 2 === 0;
+    const like = isWebSearch || isFluxMessage ? true : false;
+    return {
+      text: isFluxMessage ? `Create a beautiful ${faker.faker.color.human()} ${faker.faker.animal.type()} in a ${faker.faker.location.city()} setting, digital art style` : i === hourlyLimit ? `Find latest news about ${faker.faker.company.name()}` : `Test message ${i + 1} - ${faker.faker.lorem.sentence()}`,
+      model: isFluxMessage ? "flux" : isClaudeMessage ? "claude" : isChatGPTMessage ? "chatGPT" : "deepSeek",
+      agentMessageTimeout: isFluxMessage ? 6e4 : 3e4,
+      // Flux needs more time
+      webSearch: isWebSearch,
+      shouldFail: i === hourlyLimit,
+      // Only fail on last message
+      like
+    };
+  });
+  const failPrompt = {
+    text: "This message should fail due to hourly limit",
+    model: "deepSeek",
+    agentMessageTimeout: 3e4,
+    shouldFail: true,
+    // Flag to indicate this should fail
+    webSearch: true
+    // Test web search on the failing request too
+  };
+  await chat({
+    isNewChat: true,
+    page,
+    isMember,
+    instruction: `Testing hourly limit of ${hourlyLimit} requests`,
+    prompts: [...limitPrompts, failPrompt]
+  });
+};
+var thread = async ({
+  page,
+  isMember,
+  bookmark,
+  createChat = true
+}) => {
+  createChat && await chat({
+    bookmark,
+    isNewChat: true,
+    page,
+    isMember,
+    instruction: "Help me write a short story",
+    prompts: Array.from({ length: 3 }, (_, i) => {
+      return {
+        text: `Test message ${i + 1} - ${faker.faker.lorem.sentence()}`,
+        model: "deepSeek",
+        agentMessageTimeout: 3e4
+      };
+    })
+  });
+  const getNthThread = async (nth) => {
+    const threads = page.getByTestId("threads-item");
+    await threads.count();
+    return threads.nth(nth);
+  };
+  const getFirstThread = async () => {
+    return getNthThread(0);
+  };
+  const getSecondThread = async () => {
+    return getNthThread(1);
+  };
+  const threadsContainer = page.getByTestId("threads-container");
+  const loadMore = page.getByTestId("load-more-threads-menu");
+  if (createChat) {
+    await test.expect(loadMore).toBeVisible();
+    await loadMore.click();
+    await wait(5e3);
+  }
+  await test.expect(
+    (await getFirstThread()).getByTestId("threads-bookmarked")
+  ).toBeVisible({
+    timeout: 15e3
+  });
+  await test.expect(
+    (await getFirstThread()).getByTestId("threads-not-bookmarked")
+  ).not.toBeVisible({
+    timeout: 15e3
+  });
+  const threadsCount = page.getByTestId("threads-item");
+  const count = await threadsCount.count();
+  createChat ? test.expect(count).toBe(1) : test.expect(count).toBe(2);
+  await test.expect(threadsContainer).toBeVisible();
+  const search = page.getByTestId("threads-search");
+  await test.expect(search).toBeVisible();
+  const threadsCollaboration = page.getByTestId("threads-collaboration");
+  await test.expect(threadsCollaboration).toBeVisible();
+  const threadsSortButtonDate = page.getByTestId("threads-sort-button-date");
+  await test.expect(threadsSortButtonDate).toBeVisible();
+  await threadsSortButtonDate.click();
+  const threadsSortButton = page.getByTestId("threads-sort-button-star");
+  await test.expect(threadsSortButton).toBeVisible();
+  await threadsSortButton.click();
+  const editThreadButton = (await getFirstThread()).getByTestId(
+    "edit-thread-button"
+  );
+  await test.expect(editThreadButton).toBeVisible();
+  await editThreadButton.click();
+  const editThreadTextarea = page.getByTestId("edit-thread-textarea");
+  await editThreadTextarea.fill("New thread title");
+  const editThreadSaveButton = page.getByTestId("edit-thread-save-button");
+  await test.expect(editThreadSaveButton).toBeVisible();
+  await editThreadSaveButton.click();
+  const threadTitle = threadsContainer.getByText("New thread title");
+  await test.expect(threadTitle).toBeVisible();
+  await editThreadButton.click();
+  const editThreadGenerateTitleButton = page.getByTestId(
+    "edit-thread-generate-title-button"
+  );
+  await test.expect(editThreadGenerateTitleButton).toBeVisible();
+  await editThreadGenerateTitleButton.click();
+  await wait(2e3);
+  await editThreadSaveButton.click();
+  await wait(2e3);
+  await test.expect(threadTitle).not.toBeVisible();
+  const threadTitleGenerated2 = (await getFirstThread()).getByTestId(
+    "threads-item-title"
+  );
+  await test.expect(threadTitleGenerated2).toBeVisible();
+  const newTitle = await threadTitleGenerated2.textContent();
+  if (!newTitle) {
+    throw new Error("Thread title not found");
+  }
+  await editThreadButton.click();
+  const deleteThreadButton = page.getByTestId("delete-thread-button");
+  await test.expect(deleteThreadButton).toBeVisible();
+  await deleteThreadButton.click();
+  await wait(1e3);
+  await deleteThreadButton.click();
+  await wait(3e3);
+  await test.expect(threadsContainer).toBeVisible();
+  await test.expect(page.getByText(newTitle)).not.toBeVisible();
+  if (createChat) {
+    await chat({
+      isNewChat: true,
+      page,
+      isMember,
+      instruction: "Help me write a short story",
+      bookmark,
+      prompts: Array.from({ length: 3 }, (_, i) => {
+        return {
+          text: `Test message ${i + 1} - ${faker.faker.lorem.sentence()}`,
+          model: "deepSeek",
+          agentMessageTimeout: 3e4
+        };
+      })
+    });
+    const menuHomeButton = page.getByTestId("menu-home-button");
+    await test.expect(menuHomeButton).toBeVisible();
+    await menuHomeButton.click();
+    await wait(3e3);
+    await chat({
+      isNewChat: false,
+      creditsConsumed: 3,
+      bookmark: false,
+      page,
+      isMember,
+      instruction: "Help me write a short story",
+      prompts: Array.from({ length: 3 }, (_, i) => {
+        return {
+          text: `Test message ${i + 1} - ${faker.faker.lorem.sentence()}`,
+          model: "deepSeek",
+          agentMessageTimeout: 3e4
+        };
+      })
+    });
+    await loadMore.click();
+    await wait(1e3);
+    await test.expect(
+      (await getFirstThread()).getByTestId("threads-bookmarked")
+    ).not.toBeVisible();
+    await (await getFirstThread()).getByTestId("threads-not-bookmarked").click();
+    await wait(1e3);
+    await test.expect(
+      (await getSecondThread()).getByTestId("threads-bookmarked")
+    ).toBeVisible();
+    await test.expect(
+      (await getSecondThread()).getByTestId("threads-not-bookmarked")
+    ).not.toBeVisible();
+    await thread({
+      page,
+      isMember,
+      createChat: false
+    });
+  }
+};
+
+exports.LIVE_URL = LIVE_URL;
+exports.TEST_GUEST_FINGERPRINTS = TEST_GUEST_FINGERPRINTS;
+exports.TEST_MEMBER_EMAILS = TEST_MEMBER_EMAILS;
+exports.TEST_MEMBER_FINGERPRINTS = TEST_MEMBER_FINGERPRINTS;
+exports.TEST_URL = TEST_URL;
+exports.VEX_TEST_EMAIL = VEX_TEST_EMAIL;
+exports.VEX_TEST_EMAIL_2 = VEX_TEST_EMAIL_2;
+exports.VEX_TEST_EMAIL_3 = VEX_TEST_EMAIL_3;
+exports.VEX_TEST_FINGERPRINT = VEX_TEST_FINGERPRINT;
+exports.VEX_TEST_FINGERPRINT_2 = VEX_TEST_FINGERPRINT_2;
+exports.VEX_TEST_FINGERPRINT_3 = VEX_TEST_FINGERPRINT_3;
+exports.VEX_TEST_PASSWORD = VEX_TEST_PASSWORD;
+exports.VEX_TEST_PASSWORD_2 = VEX_TEST_PASSWORD_2;
+exports.VEX_TEST_PASSWORD_3 = VEX_TEST_PASSWORD_3;
+exports.capitalizeFirstLetter = capitalizeFirstLetter;
+exports.chat = chat;
+exports.collaboration = collaboration;
+exports.getURL = getURL;
+exports.isCI = isCI;
+exports.limit = limit;
+exports.signIn = signIn;
+exports.simulateInputPaste = simulateInputPaste;
+exports.simulatePaste = simulatePaste;
+exports.thread = thread;
+exports.wait = wait;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map