fix(whatsapp): resolve replies across scoped message ids

.gitea/workflows/build.yaml

@@ -1,24 +0,0 @@
-name: Build Chatwoot
-
-on:
-  push:
-    branches:
-      - leal-cyber
-  workflow_dispatch:
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout source
-        run: |
-          git clone --depth 1 https://github.com/chatwoot/chatwoot.git /source
-          ls /source/docker/Dockerfile
-
-      - name: Build image
-        run: |
-          cd /source
-          docker build -t gitea.lealcyber.com/akadmin/chatwoot:test             -f docker/Dockerfile             --build-arg RAILS_ENV=production             --build-arg BUNDLE_WITHOUT='development:test:enterprise'             --build-arg NODE_OPTIONS='--max-old-space-size=1024' .
-
-      - name: Verify image
-        run: docker images gitea.lealcyber.com/akadmin/chatwoot:test

.github/CODEOWNERS

@@ -0,0 +1,2 @@
+## All enterprise related files should be reviewed by sojan before merging
+/enterprise/* @sojan-official

.github/FUNDING.yml

@@ -0,0 +1,2 @@
+open_collective: chatwoot
+github: chatwoot

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -0,0 +1,78 @@
+name: 🐞 Bug report
+description: Create a report to help us improve
+labels: 'Bug'
+body:
+  - type: textarea
+    attributes:
+      label: Describe the bug
+      description: A concise description of what you expected to happen along with screenshots if applicable.
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: To Reproduce
+      description: Steps to reproduce the behavior.
+      placeholder: |
+        1. In this environment...
+        2. With this config...
+        3. Run '...'
+        4. See error...
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: Expected behavior
+      description: A concise description of what you expected to happen.
+  - type: dropdown
+    id: environment
+    attributes:
+      label: Environment
+      description: Describe whether you are using Chatwoot Cloud (app.chatwoot.com) or a self-hosted installation of Chatwoot. If you are using a self-hosted installation of Chatwoot, describe the type of deployment (Docker/Linux VM installation/Heroku/Kubernetes/Other).
+      options:
+        - app.chatwoot.com
+        - Linux VM
+        - Docker
+        - Kubernetes
+        - Heroku
+        - Other [please specify in the description]
+    validations:
+      required: true
+  - type: dropdown
+    id: provider
+    attributes:
+      label: Cloud Provider
+      description:
+      options:
+        - AWS
+        - GCP
+        - Azure
+        - DigitalOcean
+        - Other [please specify in the description]
+  - type: dropdown
+    id: platform
+    attributes:
+      label: Platform
+      description: Describe the platform you are using
+      options:
+        - Browser
+        - Mobile
+  - type: input
+    attributes:
+      label: Operating system
+      description: The operating system and the version you are using.
+  - type: input
+    attributes:
+      label: Browser and version
+      description: The name of the browser and version you are using.
+  - type: textarea
+    attributes:
+      label: Docker (if applicable)
+      description: |
+        Please share the output of the following. 
+        - `docker version`
+        - `docker info`
+        - `docker-compose version`
+  - type: textarea
+    attributes:
+      label: Additional context
+      description: Add any other context about the problem here.

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1,8 @@
+blank_issues_enabled: false
+contact_links:
+  - name: Report a security issue
+    url: https://www.chatwoot.com/docs/contributing-guide/security-reports/
+    about: Guidelines and steps to report a security vulnerability. Please report security vulnerabilities here.
+  - name: Product Documentation
+    url: https://www.chatwoot.com/help-center
+    about: If you have questions, are confused, or just want to understand our product better, please check out our documentation.

.github/ISSUE_TEMPLATE/feature_request.yml

@@ -0,0 +1,28 @@
+name: 🧙 Feature request
+description: Suggest an idea for this project
+labels: 'feature-request'
+body:
+  - type: textarea
+    attributes:
+      label: Is your feature or enhancement related to a problem? Please describe.
+      description: A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: Describe the solution you'd like
+      description: A clear and concise description of what you want to happen.
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: Describe alternatives you've considered
+      description: A clear and concise description of any alternative solutions or features you've considered.
+    validations:
+      required: false
+  - type: textarea
+    attributes:
+      label: Additional context
+      description: Add any other context or screenshots about the feature request here.
+    validations:
+      required: false

.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,31 @@
+# Pull Request Template
+
+## Description
+
+Please include a summary of the change and issue(s) fixed. Also, mention relevant motivation, context, and any dependencies that this change requires.
+Fixes # (issue)
+
+## Type of change
+
+Please delete options that are not relevant.
+
+- [ ] Bug fix (non-breaking change which fixes an issue)
+- [ ] New feature (non-breaking change which adds functionality)
+- [ ] Breaking change (fix or feature that would cause existing functionality not to work as expected)
+- [ ] This change requires a documentation update
+
+## How Has This Been Tested?
+
+Please describe the tests that you ran to verify your changes. Provide instructions so we can reproduce. Please also list any relevant details for your test configuration.
+
+
+## Checklist:
+
+- [ ] My code follows the style guidelines of this project
+- [ ] I have performed a self-review of my code
+- [ ] I have commented on my code, particularly in hard-to-understand areas
+- [ ] I have made corresponding changes to the documentation
+- [ ] My changes generate no new warnings
+- [ ] I have added tests that prove my fix is effective or that my feature works
+- [ ] New and existing unit tests pass locally with my changes
+- [ ] Any dependent changes have been merged and published in downstream modules

.github/scripts/ghsa_linear_sync.py

@@ -0,0 +1,195 @@
+#!/usr/bin/env python3
+"""Sync triage GitHub security advisories to Linear issues."""
+
+from __future__ import annotations
+
+import os
+import sys
+from typing import Any
+
+import requests
+
+GITHUB_API = "https://api.github.com"
+LINEAR_API = "https://api.linear.app/graphql"
+
+SEVERITY_PRIORITY = {"critical": 1, "high": 2, "medium": 3, "low": 4}
+SEVERITY_COLOR = {
+    "critical": 15548997,
+    "high": 15105570,
+    "medium": 15844367,
+    "low": 3066993,
+}
+DEFAULT_COLOR = 9807270
+
+
+def required_env(name: str) -> str:
+    value = os.environ.get(name)
+    if not value:
+        sys.exit(f"Missing required env var: {name}")
+    return value
+
+
+def fetch_triage_advisories(repo: str, token: str) -> list[dict[str, Any]]:
+    url: str | None = f"{GITHUB_API}/repos/{repo}/security-advisories"
+    params: dict[str, Any] | None = {"state": "triage", "per_page": 100}
+    headers = {
+        "Accept": "application/vnd.github+json",
+        "Authorization": f"Bearer {token}",
+        "X-GitHub-Api-Version": "2022-11-28",
+    }
+    advisories: list[dict[str, Any]] = []
+    while url:
+        r = requests.get(url, headers=headers, params=params, timeout=30)
+        r.raise_for_status()
+        advisories.extend(r.json())
+        next_link = r.links.get("next")
+        url = next_link["url"] if next_link else None
+        params = None
+    return advisories
+
+
+def linear_call(query: str, variables: dict[str, Any], api_key: str) -> dict[str, Any]:
+    r = requests.post(
+        LINEAR_API,
+        headers={"Authorization": api_key},
+        json={"query": query, "variables": variables},
+        timeout=30,
+    )
+    r.raise_for_status()
+    return r.json()
+
+
+def linear_issue_exists(ghsa_id: str, api_key: str) -> bool:
+    query = (
+        "query($q: String!) { issues(filter: {title: {contains: $q}}, first: 1) "
+        "{ nodes { id } } }"
+    )
+    resp = linear_call(query, {"q": ghsa_id}, api_key)
+    return len(resp.get("data", {}).get("issues", {}).get("nodes", [])) > 0
+
+
+def linear_create_issue(input_data: dict[str, Any], api_key: str) -> dict[str, str] | None:
+    query = (
+        "mutation($input: IssueCreateInput!) { issueCreate(input: $input) "
+        "{ success issue { identifier url } } }"
+    )
+    resp = linear_call(query, {"input": input_data}, api_key)
+    create = resp.get("data", {}).get("issueCreate") or {}
+    if not create.get("success"):
+        return None
+    return create.get("issue")
+
+
+def reporter_login(advisory: dict[str, Any]) -> str:
+    for credit in advisory.get("credits") or []:
+        user = (credit or {}).get("user") or {}
+        if user.get("login"):
+            return user["login"]
+    return "unknown"
+
+
+def cvss_score(advisory: dict[str, Any]) -> str:
+    score = (advisory.get("cvss") or {}).get("score")
+    return str(score) if score is not None else "n/a"
+
+
+def build_description(adv: dict[str, Any]) -> str:
+    return (
+        f"**GHSA:** {adv['ghsa_id']}\n"
+        f"**CVE:** {adv.get('cve_id') or 'n/a'}\n"
+        f"**Severity:** {adv.get('severity') or 'unknown'} (CVSS {cvss_score(adv)})\n"
+        f"**Reporter:** {reporter_login(adv)}\n"
+        f"**Reported:** {(adv.get('created_at') or '').split('T')[0]}\n"
+        f"**Advisory:** {adv['html_url']}\n\n"
+        f"---\n\n"
+        f"{adv.get('description') or 'No description provided.'}"
+    )
+
+
+def post_discord(adv: dict[str, Any], issue: dict[str, str], webhook_url: str) -> None:
+    severity = adv.get("severity") or "unknown"
+    title = f"[{adv['ghsa_id']}] {adv['summary']}"[:250]
+    payload = {
+        "username": "GHSA Sync",
+        "embeds": [
+            {
+                "title": title,
+                "url": issue["url"],
+                "color": SEVERITY_COLOR.get(severity, DEFAULT_COLOR),
+                "fields": [
+                    {"name": "Linear", "value": issue["identifier"], "inline": True},
+                    {
+                        "name": "Severity",
+                        "value": f"{severity} (CVSS {cvss_score(adv)})",
+                        "inline": True,
+                    },
+                    {
+                        "name": "Advisory",
+                        "value": f"[GitHub]({adv['html_url']})",
+                        "inline": True,
+                    },
+                ],
+            }
+        ],
+    }
+    try:
+        requests.post(webhook_url, json=payload, timeout=10)
+    except requests.RequestException:
+        pass
+
+
+def main() -> int:
+    repo = required_env("GITHUB_REPOSITORY")
+    gh_token = required_env("GHSA_READ_TOKEN")
+    linear_api_key = required_env("LINEAR_API_KEY")
+    team_id = required_env("LINEAR_TEAM_ID")
+    project_id = required_env("LINEAR_PROJECT_ID")
+    label_id = required_env("LINEAR_LABEL_ID")
+    discord_webhook = os.environ.get("DISCORD_WEBHOOK_URL") or None
+
+    advisories = fetch_triage_advisories(repo, gh_token)
+    print(f"Fetched {len(advisories)} triage advisories")
+
+    created = skipped = failed = 0
+
+    for adv in advisories:
+        ghsa_id = adv.get("ghsa_id")
+        if not ghsa_id:
+            failed += 1
+            continue
+
+        try:
+            if linear_issue_exists(ghsa_id, linear_api_key):
+                skipped += 1
+                continue
+
+            severity = adv.get("severity") or "unknown"
+            issue = linear_create_issue(
+                {
+                    "title": f"[{ghsa_id}] {adv.get('summary', '')}",
+                    "description": build_description(adv),
+                    "teamId": team_id,
+                    "projectId": project_id,
+                    "labelIds": [label_id],
+                    "priority": SEVERITY_PRIORITY.get(severity, 3),
+                },
+                linear_api_key,
+            )
+        except requests.RequestException:
+            failed += 1
+            continue
+
+        if not issue:
+            failed += 1
+            continue
+
+        created += 1
+        if discord_webhook:
+            post_discord(adv, issue, discord_webhook)
+
+    print(f"Created {created}, skipped {skipped}, failed {failed}")
+    return 1 if failed > 0 else 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

.github/workflows/auto-assign-pr.yml

@@ -0,0 +1,28 @@
+name: Auto-assign PR to Author
+
+on:
+  pull_request:
+    types: [opened]
+
+jobs:
+  auto-assign:
+    runs-on: ubuntu-latest
+    permissions:
+      pull-requests: write
+    steps:
+      - name: Auto-assign PR to author
+        uses: actions/github-script@v7
+        with:
+          script: |
+            const { owner, repo } = context.repo;
+            const pull_number = context.payload.pull_request.number;
+            const author = context.payload.pull_request.user.login;
+            
+            await github.rest.issues.addAssignees({
+              owner,
+              repo,
+              issue_number: pull_number,
+              assignees: [author]
+            });
+            
+            console.log(`Assigned PR #${pull_number} to ${author}`);

.github/workflows/deploy_check.yml

@@ -0,0 +1,53 @@
+## github action to check deployment success
+## curl the deployment url and check for 200 status
+## deployment url will be of the form chatwoot-pr-<pr_number>.herokuapp.com
+name: Deploy Check
+
+on:
+  pull_request:
+
+# If two pushes happen within a short time in the same PR, cancel the run of the oldest push
+concurrency:
+  group: pr-${{ github.workflow }}-${{ github.head_ref }}
+  cancel-in-progress: true
+
+permissions:
+  contents: read
+
+jobs:
+  deployment_check:
+    name: Check Deployment
+    runs-on: ubuntu-latest
+    steps:
+      - name: Install jq
+        run: sudo apt-get install -y jq
+      - name: Print Deployment URL
+        run: echo "https://chatwoot-pr-${{ github.event.pull_request.number }}.herokuapp.com"
+      - name: Check Deployment Status
+        run: |
+          max_attempts=10
+          attempt=1
+          status_code=0
+          echo "Waiting for review app to be deployed/redeployed, trying in  10 minutes..."
+          sleep 600
+          while [ $attempt -le $max_attempts ]; do
+            response=$(curl -s -o /dev/null -w "%{http_code}" https://chatwoot-pr-${{ github.event.pull_request.number }}.herokuapp.com/api)
+            status_code=$(echo $response | head -n   1)
+            if [ $status_code -eq   200 ]; then
+              body=$(curl -s https://chatwoot-pr-${{ github.event.pull_request.number }}.herokuapp.com/api)
+              if echo "$body" | jq -e '.version and .timestamp and .queue_services == "ok" and .data_services == "ok"' > /dev/null; then
+                echo "Deployment successful"
+                exit 0
+              else
+                echo "Deployment status unknown, retrying in   3 minutes..."
+                sleep 180
+              fi
+            else
+              echo "Waiting for review app to be ready, retrying in  3 minutes..."
+              sleep 180
+              attempt=$((attempt +  1))
+            fi
+          done
+          echo "Deployment failed after $max_attempts attempts"
+          exit  1
+          fi

.github/workflows/frontend-fe.yml

@@ -0,0 +1,44 @@
+name: Frontend Lint & Test
+
+on:
+  push:
+    branches:
+      - develop
+  pull_request:
+    branches:
+      - develop
+
+permissions:
+  contents: read
+
+jobs:
+  test:
+    runs-on: ubuntu-22.04
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: ${{ github.event.pull_request.head.ref }}
+          repository: ${{ github.event.pull_request.head.repo.full_name }}
+
+      - uses: ruby/setup-ruby@v1
+        with:
+          bundler-cache: true
+
+      - uses: pnpm/action-setup@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 24
+          cache: 'pnpm'
+
+      - name: Install pnpm dependencies
+        run: pnpm install --frozen-lockfile
+
+      - name: Run eslint
+        run: pnpm run eslint
+
+      - name: Run frontend tests with coverage
+        run: |
+          mkdir -p coverage
+          pnpm run test:coverage

.github/workflows/ghsa-linear-sync.yml

@@ -0,0 +1,29 @@
+name: Sync GHSA advisories to Linear
+
+on:
+  schedule:
+    - cron: '0 4 * * *'  # daily at 09:30 IST
+  workflow_dispatch: {}
+
+permissions:
+  contents: read
+
+jobs:
+  sync:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: '3.11'
+      - name: Install dependencies
+        run: pip install requests==2.32.3
+      - name: Sync advisories
+        env:
+          GHSA_READ_TOKEN: ${{ secrets.GHSA_READ_TOKEN }}
+          LINEAR_API_KEY: ${{ secrets.LINEAR_API_KEY }}
+          LINEAR_TEAM_ID: ${{ secrets.LINEAR_TEAM_ID }}
+          LINEAR_PROJECT_ID: ${{ secrets.LINEAR_PROJECT_ID }}
+          LINEAR_LABEL_ID: ${{ secrets.LINEAR_LABEL_ID }}
+          DISCORD_WEBHOOK_URL: ${{ secrets.DISCORD_WEBHOOK_URL }}
+        run: python3 .github/scripts/ghsa_linear_sync.py

.github/workflows/lint_pr.yml

@@ -0,0 +1,23 @@
+# ref: https://github.com/amannn/action-semantic-pull-request
+# ensure PR title is in semantic format
+
+name: "Lint PR"
+
+on:
+  pull_request_target:
+    types:
+      - opened
+      - edited
+      - synchronize
+
+permissions:
+  pull-requests: read
+
+jobs:
+  main:
+    name: Validate PR title
+    runs-on: ubuntu-latest
+    steps:
+      - uses: amannn/action-semantic-pull-request@v5
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/lock.yml

@@ -0,0 +1,29 @@
+# We often have cases where users would comment over stale closed Github Issues.
+# This creates unnecessary noise for the original reporter and makes it harder for triaging.
+# This action locks the closed threads once it is inactive for over a month.
+
+name: 'Lock Threads'
+
+on:
+  schedule:
+    - cron: '0 * * * *'
+  workflow_dispatch:
+
+permissions:
+  issues: write
+  pull-requests: write
+
+concurrency:
+  group: lock
+
+jobs:
+  action:
+    runs-on: ubuntu-latest
+    if: ${{ github.repository == 'chatwoot/chatwoot' }}
+    steps:
+      - uses: dessant/lock-threads@v3
+        with: 
+          issue-inactive-days: '30'
+          issue-lock-reason: 'resolved'
+          pr-inactive-days: '30'
+          pr-lock-reason: 'resolved'

.github/workflows/logging_percentage_check.yml

@@ -0,0 +1,63 @@
+name: Log Lines Percentage Check
+
+on:
+  pull_request:
+    branches:
+      - develop
+
+# If two pushes happen within a short time in the same PR, cancel the run of the oldest push
+concurrency:
+  group: pr-${{ github.workflow }}-${{ github.head_ref }}
+  cancel-in-progress: true
+
+permissions:
+  contents: read
+
+jobs:
+  log_lines_check:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Check for log lines and calculate percentage
+        run: |
+          # Define the log line pattern
+          LOG_LINE_PATTERN="Rails\.logger"
+
+          # Get the list of changed files in the pull request
+          CHANGED_FILES=$(git diff --name-only)
+
+          # Initialize a flag to track if any files have insufficient log lines
+          INSUFFICIENT_LOGS=0
+
+          for file in $CHANGED_FILES; do
+            if [[ $file =~ \.rb$ && ! $file =~ _spec\.rb$ ]]; then
+              # Count the total number of lines in the file
+              total_lines=$(wc -l < "$file")
+
+              # Count the number of log lines in the file
+              log_lines=$(grep -c "$LOG_LINE_PATTERN" "$file")
+
+              # Calculate the percentage of log lines
+              if [ "$total_lines" -gt 0 ]; then
+                percentage=$(awk "BEGIN { pc=100*${log_lines}/${total_lines}; i=int(pc); print (pc-i<0.5)?i:i+1 }")
+              else
+                percentage=0
+              fi
+
+              # Check if the percentage is less than 5%
+              if [ "$percentage" -lt 5 ]; then
+                echo "Error: Log lines percentage is less than 5% ($percentage%) in $file. Please add more log lines using Rails.logger statements."
+                INSUFFICIENT_LOGS=1
+              else
+                echo "Log lines percentage is $percentage% in $file. Code looks good!"
+              fi
+            fi
+          done
+
+          # If any files have insufficient log lines, fail the action
+          if [ "$INSUFFICIENT_LOGS" -eq 1 ]; then
+            exit 1
+          fi

.github/workflows/nightly_installer.yml

@@ -0,0 +1,55 @@
+# #
+# #
+# # Linux nightly installer action
+# # This action will try to install and setup
+# # chatwoot on an Ubuntu 22.04 machine using
+# # the linux installer script.
+# #
+# # This is set to run daily at midnight.
+# #
+
+name: Run Linux nightly installer
+on:
+  schedule:
+    - cron: "0 0 * * *"
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+  nightly:
+    runs-on: ubuntu-24.04
+    steps:
+
+    - name: get installer
+      run: |
+        wget https://get.chatwoot.app/linux/install.sh
+        chmod +x install.sh
+        #fix for postgtres not starting automatically in gh action env
+        sed -i '/function configure_db() {/a sudo service postgresql start' install.sh
+
+    - name: create input file
+      run: |
+        echo "no" > input
+        echo "yes" >> input
+
+    - name: Run the installer
+      run: |
+        sudo ./install.sh --install < input
+
+        #  disabling http verify for now as http
+        #  access to port 3000 fails in gh action env
+        #    - name: Verify
+        #      if: always()
+        #      run: |
+        #        sudo netstat -ntlp | grep 3000
+        #        sudo systemctl restart chatwoot.target
+        #        curl http://localhost:3000/api
+
+    - name: Upload chatwoot setup log file as an artifact
+      uses: actions/upload-artifact@v4
+      if: always()
+      with:
+        name: chatwoot-setup-log-file
+        path: /var/log/chatwoot-setup.log

.github/workflows/publish_codespace_image.yml

@@ -0,0 +1,27 @@
+name: Publish Codespace Base Image
+
+on:
+  workflow_dispatch:
+
+permissions:
+  contents: read
+  packages: write
+
+jobs:
+  publish-code-space-image:
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Login to GitHub Container Registry
+      uses: docker/login-action@v1
+      with:
+        registry: ghcr.io
+        username: ${{ github.actor }}
+        password: ${{ secrets.GITHUB_TOKEN }}
+
+    - name: Build the Codespace Base Image
+      run: |
+        docker compose -f .devcontainer/docker-compose.base.yml build base
+        docker push ghcr.io/chatwoot/chatwoot_codespace:latest

.github/workflows/publish_ee_docker.yml

@@ -0,0 +1,143 @@
+# #
+# # This action will publish Chatwoot EE docker image.
+# # This is set to run against merges to develop, master
+# # and when tags are created.
+# #
+
+name: Publish Chatwoot EE docker images
+
+on:
+  push:
+    branches:
+      - develop
+      - master
+    tags:
+      - v*
+  workflow_dispatch:
+
+env:
+  DOCKER_REPO: chatwoot/chatwoot
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - platform: linux/amd64
+            runner: ubuntu-latest
+          - platform: linux/arm64
+            runner: ubuntu-22.04-arm
+    runs-on: ${{ matrix.runner }}
+    env:
+      GIT_REF: ${{ github.head_ref || github.ref_name }}
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Prepare
+        run: |
+          platform=${{ matrix.platform }}
+          echo "PLATFORM_PAIR=${platform//\//-}" >> $GITHUB_ENV
+
+      - name: Set Chatwoot edition
+        run: |
+          echo -en '\nENV CW_EDITION="ee"' >> docker/Dockerfile
+
+      - name: Set Docker Tags
+        run: |
+          SANITIZED_REF=$(echo "$GIT_REF" | sed 's/\//-/g')
+          if [ "${{ github.ref_name }}" = "master" ]; then
+            echo "DOCKER_TAG=${DOCKER_REPO}:latest" >> $GITHUB_ENV
+          else
+            echo "DOCKER_TAG=${DOCKER_REPO}:${SANITIZED_REF}" >> $GITHUB_ENV
+          fi
+
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v3
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Login to DockerHub
+        if: github.event_name == 'push' || github.event_name == 'workflow_dispatch'
+        uses: docker/login-action@v3
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+
+      - name: Build and push by digest
+        id: build
+        uses: docker/build-push-action@v6
+        with:
+          context: .
+          file: docker/Dockerfile
+          platforms: ${{ matrix.platform }}
+          push: ${{ github.event_name == 'push' || github.event_name == 'workflow_dispatch' }}
+          outputs: type=image,name=${{ env.DOCKER_REPO }},push-by-digest=true,name-canonical=true,push=true
+
+      - name: Export digest
+        run: |
+          mkdir -p ${{ runner.temp }}/digests
+          digest="${{ steps.build.outputs.digest }}"
+          touch "${{ runner.temp }}/digests/${digest#sha256:}"
+
+      - name: Upload digest
+        uses: actions/upload-artifact@v4
+        with:
+          name: digests-${{ env.PLATFORM_PAIR }}
+          path: ${{ runner.temp }}/digests/*
+          if-no-files-found: error
+          retention-days: 1
+
+  merge:
+    runs-on: ubuntu-latest
+    needs:
+      - build
+    steps:
+      - name: Download digests
+        uses: actions/download-artifact@v4
+        with:
+          path: ${{ runner.temp }}/digests
+          pattern: digests-*
+          merge-multiple: true
+
+      - name: Login to DockerHub
+        uses: docker/login-action@v3
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Create manifest list and push
+        working-directory: ${{ runner.temp }}/digests
+        env:
+          GIT_REF: ${{ github.head_ref || github.ref_name }}
+        run: |
+          SANITIZED_REF=$(echo "$GIT_REF" | sed 's/\//-/g')
+          if [ "${{ github.ref_name }}" = "master" ]; then
+            TAG="${DOCKER_REPO}:latest"
+          else
+            TAG="${DOCKER_REPO}:${SANITIZED_REF}"
+          fi
+          
+          docker buildx imagetools create -t $TAG \
+            $(printf '${{ env.DOCKER_REPO }}@sha256:%s ' *)
+
+      - name: Inspect image
+        env:
+          GIT_REF: ${{ github.head_ref || github.ref_name }}
+        run: |
+          SANITIZED_REF=$(echo "$GIT_REF" | sed 's/\//-/g')
+          if [ "${{ github.ref_name }}" = "master" ]; then
+            TAG="${DOCKER_REPO}:latest"
+          else
+            TAG="${DOCKER_REPO}:${SANITIZED_REF}"
+          fi
+          
+          docker buildx imagetools inspect $TAG

.github/workflows/publish_foss_docker.yml

@@ -0,0 +1,148 @@
+# #
+# # This action will publish Chatwoot CE docker image.
+# # This is set to run against merges to develop, master
+# # and when tags are created.
+# #
+
+name: Publish Chatwoot CE docker images
+
+on:
+  push:
+    branches:
+      - develop
+      - master
+    tags:
+      - v*
+  workflow_dispatch:
+
+env:
+  DOCKER_REPO: chatwoot/chatwoot
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - platform: linux/amd64
+            runner: ubuntu-latest
+          - platform: linux/arm64
+            runner: ubuntu-22.04-arm
+    runs-on: ${{ matrix.runner }}
+    env:
+      GIT_REF: ${{ github.head_ref || github.ref_name }}
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Prepare
+        run: |
+          platform=${{ matrix.platform }}
+          echo "PLATFORM_PAIR=${platform//\//-}" >> $GITHUB_ENV
+
+      - name: Strip enterprise code
+        run: |
+          rm -rf enterprise
+          rm -rf spec/enterprise
+
+      - name: Set Chatwoot edition
+        run: |
+          echo -en '\nENV CW_EDITION="ce"' >> docker/Dockerfile
+
+      - name: Set Docker Tags
+        run: |
+          SANITIZED_REF=$(echo "$GIT_REF" | sed 's/\//-/g')
+          if [ "${{ github.ref_name }}" = "master" ]; then
+            echo "DOCKER_TAG=${DOCKER_REPO}:latest-ce" >> $GITHUB_ENV
+          else
+            echo "DOCKER_TAG=${DOCKER_REPO}:${SANITIZED_REF}-ce" >> $GITHUB_ENV
+          fi
+
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v3
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Login to DockerHub
+        if: github.event_name == 'push' || github.event_name == 'workflow_dispatch'
+        uses: docker/login-action@v3
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+
+      - name: Build and push by digest
+        id: build
+        uses: docker/build-push-action@v6
+        with:
+          context: .
+          file: docker/Dockerfile
+          platforms: ${{ matrix.platform }}
+          push: ${{ github.event_name == 'push' || github.event_name == 'workflow_dispatch' }}
+          outputs: type=image,name=${{ env.DOCKER_REPO }},push-by-digest=true,name-canonical=true,push=true
+
+      - name: Export digest
+        run: |
+          mkdir -p ${{ runner.temp }}/digests
+          digest="${{ steps.build.outputs.digest }}"
+          touch "${{ runner.temp }}/digests/${digest#sha256:}"
+
+      - name: Upload digest
+        uses: actions/upload-artifact@v4
+        with:
+          name: digests-${{ env.PLATFORM_PAIR }}
+          path: ${{ runner.temp }}/digests/*
+          if-no-files-found: error
+          retention-days: 1
+
+  merge:
+    runs-on: ubuntu-latest
+    needs:
+      - build
+    steps:
+      - name: Download digests
+        uses: actions/download-artifact@v4
+        with:
+          path: ${{ runner.temp }}/digests
+          pattern: digests-*
+          merge-multiple: true
+
+      - name: Login to DockerHub
+        uses: docker/login-action@v3
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Create manifest list and push
+        working-directory: ${{ runner.temp }}/digests
+        env:
+          GIT_REF: ${{ github.head_ref || github.ref_name }}
+        run: |
+          SANITIZED_REF=$(echo "$GIT_REF" | sed 's/\//-/g')
+          if [ "${{ github.ref_name }}" = "master" ]; then
+            TAG="${DOCKER_REPO}:latest-ce"
+          else
+            TAG="${DOCKER_REPO}:${SANITIZED_REF}-ce"
+          fi
+          
+          docker buildx imagetools create -t $TAG \
+            $(printf '${{ env.DOCKER_REPO }}@sha256:%s ' *)
+
+      - name: Inspect image
+        env:
+          GIT_REF: ${{ github.head_ref || github.ref_name }}
+        run: |
+          SANITIZED_REF=$(echo "$GIT_REF" | sed 's/\//-/g')
+          if [ "${{ github.ref_name }}" = "master" ]; then
+            TAG="${DOCKER_REPO}:latest-ce"
+          else
+            TAG="${DOCKER_REPO}:${SANITIZED_REF}-ce"
+          fi
+          
+          docker buildx imagetools inspect $TAG

.github/workflows/run_foss_spec.yml

@@ -0,0 +1,146 @@
+name: Run Chatwoot CE spec
+permissions:
+  contents: read
+on:
+  push:
+    branches:
+      - develop
+      - master
+  pull_request:
+  workflow_dispatch:
+
+jobs:
+  # Separate linting jobs for faster feedback
+  lint-backend:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: ruby/setup-ruby@v1
+        with:
+          bundler-cache: true
+      - name: Run Rubocop
+        run: bundle exec rubocop --parallel
+
+  lint-frontend:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: pnpm/action-setup@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 24
+          cache: 'pnpm'
+      - name: Install pnpm dependencies
+        run: pnpm i
+      - name: Run ESLint
+        run: pnpm run eslint
+
+  # Frontend tests run in parallel with backend
+  frontend-tests:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: pnpm/action-setup@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 24
+          cache: 'pnpm'
+      - name: Install pnpm dependencies
+        run: pnpm i
+      - name: Run frontend tests
+        run: pnpm run test:coverage
+
+  # Backend tests with parallelization
+  backend-tests:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        ci_node_total: [16]
+        ci_node_index: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
+
+    services:
+      postgres:
+        image: pgvector/pgvector:pg16
+        env:
+          POSTGRES_USER: postgres
+          POSTGRES_PASSWORD: ''
+          POSTGRES_DB: postgres
+          POSTGRES_HOST_AUTH_METHOD: trust
+        ports:
+          - 5432:5432
+        options: >-
+          --mount type=tmpfs,destination=/var/lib/postgresql/data
+          --health-cmd pg_isready
+          --health-interval 10s
+          --health-timeout 5s
+          --health-retries 5
+      redis:
+        image: redis:alpine
+        ports:
+          - 6379:6379
+        options: --entrypoint redis-server
+
+    steps:
+      - uses: actions/checkout@v4
+      - uses: pnpm/action-setup@v4
+        with:
+          ref: ${{ github.event.pull_request.head.ref }}
+          repository: ${{ github.event.pull_request.head.repo.full_name }}
+
+      - uses: ruby/setup-ruby@v1
+        with:
+          bundler-cache: true
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 24
+          cache: 'pnpm'
+
+      - name: Install pnpm dependencies
+        run: pnpm i
+
+      - name: Strip enterprise code
+        run: |
+          rm -rf enterprise
+          rm -rf spec/enterprise
+
+      - name: Create database
+        run: bundle exec rake db:create
+
+      - name: Seed database
+        run: bundle exec rake db:schema:load
+
+      - name: Run backend tests (parallelized)
+        run: |
+          # Get all spec files and split them using round-robin distribution
+          # This ensures slow tests are distributed evenly across all nodes
+          SPEC_FILES=($(find spec -name '*_spec.rb' | sort))
+          TESTS=""
+
+          for i in "${!SPEC_FILES[@]}"; do
+            # Assign spec to this node if: index % total == node_index
+            if [ $(( i % ${{ matrix.ci_node_total }} )) -eq ${{ matrix.ci_node_index }} ]; then
+              TESTS="$TESTS ${SPEC_FILES[$i]}"
+            fi
+          done
+
+          if [ -n "$TESTS" ]; then
+            bundle exec rspec --profile=10 --format progress --format json --out tmp/rspec_results.json $TESTS
+          fi
+        env:
+          NODE_OPTIONS: --openssl-legacy-provider
+
+      - name: Upload test results
+        uses: actions/upload-artifact@v4
+        if: always()
+        with:
+          name: rspec-results-${{ matrix.ci_node_index }}
+          path: tmp/rspec_results.json
+
+      - name: Upload rails log folder
+        uses: actions/upload-artifact@v4
+        if: failure()
+        with:
+          name: rails-log-folder-${{ matrix.ci_node_index }}
+          path: log

.github/workflows/run_mfa_spec.yml

@@ -0,0 +1,100 @@
+name: Run MFA Tests
+permissions:
+  contents: read
+
+on:
+  pull_request:
+
+# If two pushes happen within a short time in the same PR, cancel the run of the oldest push
+concurrency:
+  group: pr-${{ github.workflow }}-${{ github.head_ref }}
+  cancel-in-progress: true
+
+jobs:
+  test:
+    runs-on: ubuntu-22.04
+    # Only run if MFA test keys are available
+    if: github.event_name == 'workflow_dispatch' || (github.repository == 'chatwoot/chatwoot' && github.actor != 'dependabot[bot]')
+
+    services:
+      postgres:
+        image: pgvector/pgvector:pg15
+        env:
+          POSTGRES_USER: postgres
+          POSTGRES_PASSWORD: ''
+          POSTGRES_DB: postgres
+          POSTGRES_HOST_AUTH_METHOD: trust
+        ports:
+          - 5432:5432
+        options: >-
+          --mount type=tmpfs,destination=/var/lib/postgresql/data
+          --health-cmd pg_isready
+          --health-interval 10s
+          --health-timeout 5s
+          --health-retries 5
+      redis:
+        image: redis
+        ports:
+          - 6379:6379
+        options: --entrypoint redis-server
+
+    env:
+      RAILS_ENV: test
+      POSTGRES_HOST: localhost
+      # Active Record encryption keys required for MFA - test keys only, not for production use
+      ACTIVE_RECORD_ENCRYPTION_PRIMARY_KEY: 'test_key_a6cde8f7b9c2d3e4f5a6b7c8d9e0f1a2b3c4d5e6f7a8b9c0d1e2f3a4b5c6d7'
+      ACTIVE_RECORD_ENCRYPTION_DETERMINISTIC_KEY: 'test_key_b7def9a8c0d3e4f5a6b7c8d9e0f1a2b3c4d5e6f7a8b9c0d1e2f3a4b5c6d8'
+      ACTIVE_RECORD_ENCRYPTION_KEY_DERIVATION_SALT: 'test_salt_c8efa0b9d1e4f5a6b7c8d9e0f1a2b3c4d5e6f7a8b9c0d1e2f3a4b5c6d9'
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: ruby/setup-ruby@v1
+        with:
+          bundler-cache: true
+
+      - name: Create database
+        run: bundle exec rake db:create
+
+      - name: Install pgvector extension
+        run: |
+          PGPASSWORD="" psql -h localhost -U postgres -d chatwoot_test -c "CREATE EXTENSION IF NOT EXISTS vector;"
+
+      - name: Seed database
+        run: bundle exec rake db:schema:load
+
+      - name: Run MFA-related backend tests
+        run: |
+          bundle exec rspec \
+            spec/services/mfa/token_service_spec.rb \
+            spec/services/mfa/authentication_service_spec.rb \
+            spec/requests/api/v1/profile/mfa_controller_spec.rb \
+            spec/controllers/devise_overrides/sessions_controller_spec.rb \
+            spec/models/application_record_external_credentials_encryption_spec.rb \
+            --profile=10 \
+            --format documentation
+        env:
+          NODE_OPTIONS: --openssl-legacy-provider
+
+      - name: Run MFA-related tests in user_spec
+        run: |
+          # Run specific MFA-related tests from user_spec
+          bundle exec rspec spec/models/user_spec.rb \
+            -e "two factor" \
+            -e "2FA" \
+            -e "MFA" \
+            -e "otp" \
+            -e "backup code" \
+            --profile=10 \
+            --format documentation
+        env:
+          NODE_OPTIONS: --openssl-legacy-provider
+
+      - name: Upload test logs
+        uses: actions/upload-artifact@v4
+        if: failure()
+        with:
+          name: mfa-test-logs
+          path: |
+            log/test.log
+            tmp/screenshots/

.github/workflows/size-limit.yml

@@ -0,0 +1,55 @@
+name: Run Size Limit Check
+
+on:
+  pull_request:
+    branches:
+      - develop
+
+# If two pushes happen within a short time in the same PR, cancel the run of the oldest push
+concurrency:
+  group: pr-${{ github.workflow }}-${{ github.head_ref }}
+  cancel-in-progress: true
+
+permissions:
+  contents: read
+
+jobs:
+  test:
+    runs-on: ubuntu-22.04
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: ${{ github.event.pull_request.head.ref }}
+          repository: ${{ github.event.pull_request.head.repo.full_name }}
+
+      - uses: ruby/setup-ruby@v1
+        with:
+          bundler-cache: true # runs 'bundle install' and caches installed gems automatically
+
+      - uses: pnpm/action-setup@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 24
+          cache: 'pnpm'
+
+      - name: pnpm
+        run: pnpm install
+
+      - name: Strip enterprise code
+        run: |
+          rm -rf enterprise
+          rm -rf spec/enterprise
+
+      - name: setup env
+        run: |
+          cp .env.example .env
+
+      - name: Run asset compile
+        run: bundle exec rake assets:precompile
+        env:
+          RAILS_ENV: production
+
+      - name: Size Check
+        run: pnpm run size

.github/workflows/stale.yml

@@ -0,0 +1,28 @@
+# This workflow warns and then closes PRs that have had no activity for a specified amount of time.
+#
+# You can adjust the behavior by modifying this file.
+# For more information, see:
+# https://github.com/actions/stale
+name: Mark stale issues and pull requests
+
+on:
+  schedule:
+  - cron: '28 3 * * *'
+
+jobs:
+  stale:
+
+    runs-on: ubuntu-latest
+    permissions:
+      pull-requests: write
+
+    steps:
+    - uses: actions/stale@v5
+      with:
+        repo-token: ${{ secrets.GITHUB_TOKEN }}
+        days-before-issue-close: -1,
+        days-before-issue-stale: -1
+        days-before-pr-close: -1,
+        days-before-pr-stale: 30,
+        stale-pr-message: '🐢 Turtley slow progress alert! This pull request has been idle for over 30 days. Can we please speed things up and either merge it or release it back into the wild?'
+        stale-pr-label: 'stale'

.github/workflows/test_docker_build.yml

@@ -0,0 +1,43 @@
+name: Test Docker Build
+
+on:
+  pull_request:
+    branches:
+      - develop
+      - master
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+  test-build:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - platform: linux/amd64
+            runner: ubuntu-latest
+          - platform: linux/arm64
+            runner: ubuntu-22.04-arm
+    runs-on: ${{ matrix.runner }}
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v3
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Build Docker image
+        uses: docker/build-push-action@v6
+        with:
+          context: .
+          file: docker/Dockerfile
+          platforms: ${{ matrix.platform }}
+          push: false
+          load: false
+          cache-from: type=gha,scope=${{ matrix.platform }}
+          cache-to: type=gha,mode=max,scope=${{ matrix.platform }}

README.md

@@ -137,9 +137,3 @@ Thanks goes to all these [wonderful people](https://www.chatwoot.com/docs/contri
 
 
 *Chatwoot* © 2017-2026, Chatwoot Inc - Released under the MIT License.
-# Trigger rebuild
-### Runner test
-
-
-
-

VERSION_CW

@@ -1 +1 @@
-4.16.1
+4.16.0

app/builders/agent_builder.rb

@@ -2,14 +2,6 @@
 # It initializes with necessary attributes and provides a perform method
 # to create a user and account user in a transaction.
 class AgentBuilder
-  LIMIT_EXCEEDED_MESSAGE = 'Account limit exceeded. Please purchase more licenses'.freeze
-
-  class LimitExceededError < StandardError
-    def initialize
-      super(AgentBuilder::LIMIT_EXCEEDED_MESSAGE)
-    end
-  end
-
   # Initializes an AgentBuilder with necessary attributes.
   # @param email [String] the email of the user.
   # @param name [String] the name of the user.
@@ -22,23 +14,15 @@ class AgentBuilder
   # Creates a user and account user in a transaction.
   # @return [User] the created user.
   def perform
-    account.with_lock do
-      raise LimitExceededError unless can_add_agent?
-
-      ActiveRecord::Base.transaction do
-        @user = find_or_create_user
-        create_account_user
-      end
+    ActiveRecord::Base.transaction do
+      @user = find_or_create_user
+      create_account_user
     end
     @user
   end
 
   private
 
-  def can_add_agent?
-    account.usage_limits[:agents] > account.account_users.count
-  end
-
   # Finds a user by email or creates a new one with a temporary password.
   # @return [User] the found or created user.
   def find_or_create_user

app/controllers/api/v1/accounts/agents_controller.rb

@@ -1,6 +1,8 @@
 class Api::V1::Accounts::AgentsController < Api::V1::Accounts::BaseController
   before_action :fetch_agent, except: [:create, :index, :bulk_create]
   before_action :check_authorization
+  before_action :validate_limit, only: [:create]
+  before_action :validate_limit_for_bulk_create, only: [:bulk_create]
 
   def index
     @agents = agents
@@ -18,8 +20,6 @@ class Api::V1::Accounts::AgentsController < Api::V1::Accounts::BaseController
     )
 
     @agent = builder.perform
-  rescue AgentBuilder::LimitExceededError => e
-    render_payment_required(e.message)
   end
 
   def update
@@ -36,13 +36,25 @@ class Api::V1::Accounts::AgentsController < Api::V1::Accounts::BaseController
   def bulk_create
     emails = params[:emails]
 
-    bulk_create_agents(emails)
+    emails.each do |email|
+      builder = AgentBuilder.new(
+        email: email,
+        name: email.split('@').first,
+        inviter: current_user,
+        account: Current.account
+      )
+      begin
+        builder.perform
+      rescue ActiveRecord::RecordInvalid => e
+        Rails.logger.info "[Agent#bulk_create] ignoring email #{email}, errors: #{e.record.errors}"
+      end
+    end
+
     # This endpoint is used to bulk create agents during onboarding
     # onboarding_step key in present in Current account custom attributes, since this is a one time operation
-    clear_onboarding_step
+    Current.account.custom_attributes.delete('onboarding_step')
+    Current.account.save!
     head :ok
-  rescue AgentBuilder::LimitExceededError => e
-    render_payment_required(e.message)
   end
 
   private
@@ -75,33 +87,22 @@ class Api::V1::Accounts::AgentsController < Api::V1::Accounts::BaseController
     @agents ||= Current.account.users.order_by_full_name.includes(:account_users, { avatar_attachment: [:blob] })
   end
 
-  def bulk_create_agents(emails)
-    Current.account.with_lock do
-      raise AgentBuilder::LimitExceededError if emails.count > available_agent_count
+  def validate_limit_for_bulk_create
+    limit_available = params[:emails].count <= available_agent_count
 
-      emails.each { |email| create_agent_from_email(email) }
-    end
+    render_payment_required('Account limit exceeded. Please purchase more licenses') unless limit_available
   end
 
-  def create_agent_from_email(email)
-    builder = AgentBuilder.new(
-      email: email,
-      name: email.split('@').first,
-      inviter: current_user,
-      account: Current.account
-    )
-    builder.perform
-  rescue ActiveRecord::RecordInvalid => e
-    Rails.logger.info "[Agent#bulk_create] ignoring email #{email}, errors: #{e.record.errors}"
-  end
-
-  def clear_onboarding_step
-    Current.account.custom_attributes.delete('onboarding_step')
-    Current.account.save!
+  def validate_limit
+    render_payment_required('Account limit exceeded. Please purchase more licenses') unless can_add_agent?
   end
 
   def available_agent_count
-    Current.account.usage_limits[:agents] - Current.account.account_users.count
+    Current.account.usage_limits[:agents] - agents.count
+  end
+
+  def can_add_agent?
+    available_agent_count.positive?
   end
 
   def delete_user_record(agent)

app/controllers/api/v1/accounts/integrations/base_controller.rb

@@ -1,9 +0,0 @@
-class Api::V1::Accounts::Integrations::BaseController < Api::V1::Accounts::BaseController
-  private
-
-  # Managing an integration hook (create/update/destroy) is admin-only, enforced via HookPolicy.
-  # Subclasses opt in per action with `before_action :check_authorization, only: [...]`.
-  def check_authorization
-    authorize(:hook)
-  end
-end

app/controllers/api/v1/accounts/integrations/hooks_controller.rb

@@ -1,4 +1,4 @@
-class Api::V1::Accounts::Integrations::HooksController < Api::V1::Accounts::Integrations::BaseController
+class Api::V1::Accounts::Integrations::HooksController < Api::V1::Accounts::BaseController
   before_action :fetch_hook, except: [:create]
   before_action :check_authorization
 
@@ -35,6 +35,10 @@ class Api::V1::Accounts::Integrations::HooksController < Api::V1::Accounts::Inte
     @hook = Current.account.hooks.find(params[:id])
   end
 
+  def check_authorization
+    authorize(:hook)
+  end
+
   def permitted_params
     params.require(:hook).permit(:app_id, :inbox_id, :status, settings: {})
   end

app/controllers/api/v1/accounts/integrations/linear_controller.rb

@@ -1,7 +1,6 @@
-class Api::V1::Accounts::Integrations::LinearController < Api::V1::Accounts::Integrations::BaseController
+class Api::V1::Accounts::Integrations::LinearController < Api::V1::Accounts::BaseController
   before_action :fetch_conversation, only: [:create_issue, :link_issue, :unlink_issue, :linked_issues]
   before_action :fetch_hook, only: [:destroy]
-  before_action :check_authorization, only: [:destroy]
 
   def destroy
     revoke_linear_token

app/controllers/api/v1/accounts/integrations/notion_controller.rb

@@ -1,6 +1,5 @@
-class Api::V1::Accounts::Integrations::NotionController < Api::V1::Accounts::Integrations::BaseController
+class Api::V1::Accounts::Integrations::NotionController < Api::V1::Accounts::BaseController
   before_action :fetch_hook, only: [:destroy]
-  before_action :check_authorization, only: [:destroy]
 
   def destroy
     @hook.destroy!

app/controllers/api/v1/accounts/integrations/shopify_controller.rb

@@ -1,8 +1,7 @@
-class Api::V1::Accounts::Integrations::ShopifyController < Api::V1::Accounts::Integrations::BaseController
+class Api::V1::Accounts::Integrations::ShopifyController < Api::V1::Accounts::BaseController
   include Shopify::IntegrationHelper
   before_action :setup_shopify_context, only: [:orders]
   before_action :fetch_hook, except: [:auth]
-  before_action :check_authorization, only: [:destroy]
   before_action :validate_contact, only: [:orders]
 
   def auth

app/controllers/api/v1/accounts/whatsapp/authorizations_controller.rb

@@ -1,5 +1,4 @@
 class Api::V1::Accounts::Whatsapp::AuthorizationsController < Api::V1::Accounts::BaseController
-  before_action :ensure_embedded_signup_enabled
   # Reconfiguring/reauthorizing a live inbox swaps its credentials, so restrict it to admins.
   before_action :check_admin_authorization?, if: -> { params[:inbox_id].present? }
   before_action :fetch_and_validate_inbox, if: -> { params[:inbox_id].present? }
@@ -19,13 +18,6 @@ class Api::V1::Accounts::Whatsapp::AuthorizationsController < Api::V1::Accounts:
 
   private
 
-  def ensure_embedded_signup_enabled
-    return unless ChatwootApp.chatwoot_cloud?
-    return if Current.account.feature_enabled?('whatsapp_embedded_signup_inbox_creation')
-
-    raise Pundit::NotAuthorizedError
-  end
-
   def process_embedded_signup
     service = Whatsapp::EmbeddedSignupService.new(
       account: Current.account,
@@ -52,7 +44,8 @@ class Api::V1::Accounts::Whatsapp::AuthorizationsController < Api::V1::Accounts:
   def can_reconfigure_channel?
     channel = @inbox.channel
     return false unless channel.provider == 'whatsapp_cloud'
-    return true if ChatwootApp.chatwoot_cloud?
+
+    # Reconfiguring a live embedded-signup channel requires the feature flag.
     return Current.account.feature_enabled?('whatsapp_reconfigure') if channel.provider_config['source'] == 'embedded_signup'
 
     true

app/controllers/webhooks/whatsapp_controller.rb

@@ -47,10 +47,18 @@ class Webhooks::WhatsappController < ActionController::API
     metadata = params.dig(:entry, 0, :changes, 0, :value, :metadata)
     return if metadata.blank?
 
-    Whatsapp::WebhookChannelFinderService.new(
-      display_phone_number: metadata[:display_phone_number],
-      phone_number_id: metadata[:phone_number_id]
-    ).perform
+    phone_number = normalized_phone_number(metadata[:display_phone_number])
+    phone_number_id = metadata[:phone_number_id]
+    channel = Channel::Whatsapp.find_by(phone_number: phone_number)
+
+    return channel if channel && channel.provider_config['phone_number_id'] == phone_number_id
+  end
+
+  def normalized_phone_number(phone_number)
+    return if phone_number.blank?
+
+    phone_number = phone_number.to_s
+    phone_number.start_with?('+') ? phone_number : "+#{phone_number}"
   end
 
   def inactive_whatsapp_number?

app/javascript/dashboard/api/captain/agentSessions.js

@@ -1,9 +0,0 @@
-import ApiClient from '../ApiClient';
-
-class CaptainAgentSessions extends ApiClient {
-  constructor() {
-    super('captain/agent_sessions', { accountScoped: true });
-  }
-}
-
-export default new CaptainAgentSessions();

app/javascript/dashboard/api/captain/assistant.js

@@ -26,25 +26,15 @@ class CaptainAssistant extends ApiClient {
     });
   }
 
-  getMetrics({ assistantId, range, signal }) {
-    const requestConfig = {
+  getStats({ assistantId, range }) {
+    return axios.get(`${this.url}/${assistantId}/stats`, {
       params: { range, timezone_offset: getTimezoneOffset() },
-    };
-    if (signal) requestConfig.signal = signal;
-
-    return axios.get(`${this.url}/${assistantId}/metrics`, requestConfig);
+    });
   }
 
-  getFaqStats({ assistantId, signal }) {
-    const requestConfig = {};
-    if (signal) requestConfig.signal = signal;
-
-    return axios.get(`${this.url}/${assistantId}/faq_stats`, requestConfig);
-  }
-
-  getSummary({ assistantId, range, stats }) {
+  getSummary({ assistantId, range }) {
     return axios.get(`${this.url}/${assistantId}/summary`, {
-      params: { range, timezone_offset: getTimezoneOffset(), stats },
+      params: { range, timezone_offset: getTimezoneOffset() },
     });
   }
 

app/javascript/dashboard/api/channel/whatsapp/whatsappCallsAPI.js

@@ -10,13 +10,10 @@ class WhatsappCallsAPI extends ApiClient {
     return axios.get(`${this.url}/${callId}`).then(r => r.data);
   }
 
-  // Either conversationId, or contactId + inboxId to let the BE resolve the conversation.
-  initiate({ conversationId, contactId, inboxId }, sdpOffer) {
+  initiate(conversationId, sdpOffer) {
     return axios
       .post(`${this.url}/initiate`, {
         conversation_id: conversationId,
-        contact_id: contactId,
-        inbox_id: inboxId,
         sdp_offer: sdpOffer,
       })
       .then(r => r.data);

app/javascript/dashboard/components-next/AssignmentPolicy/AssignmentPolicyCard/AssignmentPolicyCard.vue

@@ -28,12 +28,7 @@ const inboxes = computed(() => {
     return {
       name: inbox.name,
       id: inbox.id,
-      icon: getInboxIconByType(
-        inbox.channelType,
-        inbox.medium,
-        'line',
-        inbox.voiceEnabled
-      ),
+      icon: getInboxIconByType(inbox.channelType, inbox.medium, 'line'),
     };
   });
 });

app/javascript/dashboard/components-next/Calls/CallListItem.vue

@@ -3,7 +3,6 @@ import { computed } from 'vue';
 import { useRoute } from 'vue-router';
 import { useI18n } from 'vue-i18n';
 import { relativeDayTimestamp } from 'shared/helpers/timeHelper';
-import { getInboxVoiceIcon } from 'dashboard/helper/inbox';
 import Avatar from 'dashboard/components-next/avatar/Avatar.vue';
 import Icon from 'dashboard/components-next/icon/Icon.vue';
 import AudioPlayer from 'dashboard/components-next/audio/AudioPlayer.vue';
@@ -26,11 +25,8 @@ const route = useRoute();
 
 const kind = computed(() => getCallKind(props.call));
 
-const contactName = computed(() =>
-  (props.call.contact.name || props.call.contact.phoneNumber || '').replace(
-    /^\+/,
-    ''
-  )
+const contactName = computed(
+  () => props.call.contact.name || props.call.contact.phoneNumber
 );
 
 const agentActionLabel = computed(() => {
@@ -61,7 +57,7 @@ const resultLabel = computed(() => {
 });
 
 const providerIcon = computed(() =>
-  getInboxVoiceIcon(props.call.inbox.channelType, props.call.inbox.medium)
+  props.call.provider === 'whatsapp' ? 'i-woot-whatsapp' : 'i-lucide-phone'
 );
 
 const createdAtLabel = computed(() =>
@@ -151,7 +147,7 @@ const conversationRoute = computed(() => ({
   <div
     class="hidden items-center gap-x-1.5 gap-y-2.5 border-b border-n-weak lg:flex lg:items-center lg:gap-1.5"
   >
-    <div class="flex items-center gap-2.5 min-w-0 w-52 shrink-0 py-3.5">
+    <div class="flex items-center gap-2.5 min-w-0 w-40 shrink-0 py-3.5">
       <Avatar
         :src="call.contact.avatar"
         :name="contactName"
@@ -170,12 +166,9 @@ const conversationRoute = computed(() => ({
     >
       <div class="flex items-center gap-x-2 min-w-0 lg:contents py-3.5">
         <CallStatusBadge :kind="kind" class="shrink-0" />
-        <div
-          v-if="agentActionLabel"
-          class="gap-x-1.5 min-w-0 flex items-center"
-        >
+        <template v-if="agentActionLabel">
           <span
-            class="text-label-small text-n-slate-10 truncate shrink min-w-8 xl:min-w-14"
+            class="text-label-small text-n-slate-10 truncate min-w-0 shrink min-w-8"
           >
             {{ agentActionLabel }}
           </span>
@@ -196,7 +189,7 @@ const conversationRoute = computed(() => ({
               {{ call.agent.name }}
             </span>
           </span>
-        </div>
+        </template>
         <span
           v-else-if="resultLabel"
           class="text-body-main truncate text-n-slate-10 min-w-0 shrink-[20]"
@@ -216,10 +209,10 @@ const conversationRoute = computed(() => ({
         content: call.inbox.name,
         delay: { show: 500, hide: 0 },
       }"
-      class="flex items-center gap-1 justify-end w-40 min-w-4 shrink-[100] py-3.5"
+      class="flex items-center gap-1.5 justify-start min-w-14 shrink-[100] py-3.5"
     >
       <Icon :icon="providerIcon" class="size-4 text-n-slate-11 shrink-0" />
-      <span class="text-body-main truncate text-n-slate-11 min-w-0">
+      <span class="text-body-main truncate text-n-slate-11">
         {{ call.inbox.name }}
       </span>
     </div>
@@ -236,7 +229,7 @@ const conversationRoute = computed(() => ({
         content: createdAtLabel,
         delay: { show: 500, hide: 0 },
       }"
-      class="text-label-small text-end text-n-slate-11 truncate py-3.5 tabular-nums justify-self-end min-w-16 max-w-20 shrink-0"
+      class="text-label-small text-end text-n-slate-11 truncate py-3.5 tabular-nums justify-self-end w-16 shrink-0"
     >
       {{ createdAtLabel }}
     </span>

app/javascript/dashboard/components-next/Calls/CallsFilterBar.vue

@@ -5,7 +5,6 @@ import { useI18n } from 'vue-i18n';
 import Button from 'dashboard/components-next/button/Button.vue';
 import DropdownMenu from 'dashboard/components-next/dropdown-menu/DropdownMenu.vue';
 import Icon from 'dashboard/components-next/icon/Icon.vue';
-import Avatar from 'dashboard/components-next/avatar/Avatar.vue';
 
 const props = defineProps({
   // Null while a fetch is in flight so stale counts are never shown.
@@ -118,16 +117,10 @@ const moreFiltersSections = computed(() => [
   },
 ]);
 
-const selectedAssignee = computed(
-  () => props.agents.find(agent => agent.id === assigneeId.value) || null
-);
-
 const selectedAssigneeLabel = computed(
-  () => selectedAssignee.value?.name || t('CALLS_PAGE.FILTERS.ASSIGNEE')
-);
-
-const isOtherActivitySelected = computed(() =>
-  OTHER_ACTIVITIES.includes(activity.value)
+  () =>
+    props.agents.find(agent => agent.id === assigneeId.value)?.name ||
+    t('CALLS_PAGE.FILTERS.ASSIGNEE')
 );
 
 const hasMoreFilters = computed(() => Boolean(inboxId.value));
@@ -150,7 +143,7 @@ const applyMoreFilter = ({ action, value }) => {
 
 <template>
   <div class="flex flex-wrap items-center justify-between gap-3">
-    <div class="flex flex-wrap items-center gap-2">
+    <div class="flex flex-wrap items-center gap-3">
       <span v-if="!activity" class="text-heading-3 text-n-slate-11 shrink-0">
         {{
           totalCount === null
@@ -164,13 +157,13 @@ const applyMoreFilter = ({ action, value }) => {
         color="blue"
         size="sm"
         :icon="ACTIVITY_ICONS[activity]"
-        class="shrink-0 !h-7 !px-2"
+        class="shrink-0"
         @click="setActivity(null)"
       >
         {{ activeChipLabel }}
         <Icon icon="i-lucide-x" />
       </Button>
-      <div class="w-px h-3.5 mx-1 bg-n-strong shrink-0" />
+      <div class="w-px h-4 bg-n-strong shrink-0" />
       <Button
         v-for="chip in inactiveChips"
         :key="chip"
@@ -179,7 +172,7 @@ const applyMoreFilter = ({ action, value }) => {
         size="sm"
         :icon="ACTIVITY_ICONS[chip]"
         :label="activityLabel(chip)"
-        class="shrink-0 text-n-slate-11 !h-7 !px-2"
+        class="shrink-0 text-n-slate-12"
         @click="setActivity(chip)"
       />
       <OnClickOutside
@@ -191,10 +184,7 @@ const applyMoreFilter = ({ action, value }) => {
           color="slate"
           size="sm"
           icon="i-lucide-phone"
-          class="!h-7 !px-2"
-          :class="
-            isOtherActivitySelected ? 'text-n-slate-12' : 'text-n-slate-11'
-          "
+          class="text-n-slate-12"
           @click="toggleMenu('activity')"
         >
           {{ t('CALLS_PAGE.FILTERS.OTHER_ACTIVITY') }}
@@ -218,19 +208,10 @@ const applyMoreFilter = ({ action, value }) => {
           variant="outline"
           color="slate"
           size="sm"
-          icon="i-woot-empty-assignee"
-          class="max-w-52 !h-7 !px-2"
-          :class="assigneeId ? 'text-n-slate-12' : 'text-n-slate-11'"
+          icon="i-lucide-user-round-cog"
+          class="max-w-52 text-n-slate-12"
           @click="toggleMenu('assignee')"
         >
-          <template v-if="selectedAssignee" #icon>
-            <Avatar
-              :src="selectedAssignee.thumbnail"
-              :name="selectedAssignee.name"
-              :size="16"
-              rounded-full
-            />
-          </template>
           <span class="truncate">{{ selectedAssigneeLabel }}</span>
           <Icon icon="i-lucide-chevron-down" class="text-n-slate-11 shrink-0" />
         </Button>
@@ -247,9 +228,8 @@ const applyMoreFilter = ({ action, value }) => {
           variant="outline"
           size="sm"
           icon="i-lucide-list-filter"
-          class="!h-7 !px-2"
           :color="hasMoreFilters ? 'blue' : 'slate'"
-          :class="hasMoreFilters ? '' : 'text-n-slate-11'"
+          :class="hasMoreFilters ? '' : 'text-n-slate-12'"
           @click="toggleMenu('more')"
         >
           {{ t('CALLS_PAGE.FILTERS.MORE_FILTERS') }}

app/javascript/dashboard/components-next/Campaigns/CampaignCard/CampaignCard.vue

@@ -83,12 +83,8 @@ const campaignStatus = computed(() => {
 const inboxName = computed(() => props.inbox?.name || '');
 
 const inboxIcon = computed(() => {
-  const {
-    medium,
-    channel_type: type,
-    voice_enabled: voiceEnabled,
-  } = props.inbox;
-  return getInboxIconByType(type, medium, 'fill', voiceEnabled);
+  const { medium, channel_type: type } = props.inbox;
+  return getInboxIconByType(type, medium);
 });
 </script>
 

app/javascript/dashboard/components-next/Contacts/VoiceCallButton.vue

@@ -16,6 +16,7 @@ import { useAlert } from 'dashboard/composables';
 import { frontendURL, conversationUrl } from 'dashboard/helper/URLHelper';
 import { useCallsStore } from 'dashboard/stores/calls';
 import { useWhatsappCallSession } from 'dashboard/composables/useWhatsappCallSession';
+import ContactAPI from 'dashboard/api/contacts';
 
 import Button from 'dashboard/components-next/button/Button.vue';
 import Dialog from 'dashboard/components-next/dialog/Dialog.vue';
@@ -82,18 +83,39 @@ const navigateToConversation = conversationId => {
 
 const whatsappCallSession = useWhatsappCallSession();
 
+// Find the most recent open conversation for this contact in the picked inbox.
+// WhatsApp /initiate is conversation-scoped (unlike Twilio's contact-scoped path).
+// Pass inboxId so the BE applies the filter before the 20-row cap — without it,
+// contacts whose latest WhatsApp conversation falls outside the 20 most recent
+// across all inboxes would be treated as having no conversation.
+const findWhatsappConversationId = async inboxId => {
+  const { data } = await ContactAPI.getConversations(props.contactId, {
+    inboxId,
+  });
+  const conversations = data?.payload || [];
+  const match = [...conversations].sort(
+    (a, b) => (b.last_activity_at || 0) - (a.last_activity_at || 0)
+  )[0];
+  return match?.id || null;
+};
+
 const startWhatsappCall = async (inboxId, conversationIdHint) => {
-  const response = await whatsappCallSession.initiateOutboundCall(
-    conversationIdHint
-      ? { conversationId: conversationIdHint }
-      : { contactId: props.contactId, inboxId }
-  );
+  // WhatsApp /initiate is conversation-scoped, so we must hand it a
+  // conversation. Use the caller's hint when given (in-conversation flow);
+  // otherwise pick the most recent one in the inbox.
+  const conversationId =
+    conversationIdHint || (await findWhatsappConversationId(inboxId));
+  if (!conversationId) {
+    useAlert(t('CONTACT_PANEL.CALL_FAILED'));
+    return;
+  }
+
+  const response =
+    await whatsappCallSession.initiateOutboundCall(conversationId);
   // The composable returns { status: 'locked' } when an init is already in
   // flight or a call is already active; treat that as a soft no-op rather than
   // claiming success.
   if (response?.status === VOICE_CALL_OUTBOUND_INIT_STATUS.LOCKED) return;
-
-  const conversationId = response?.conversation_id || conversationIdHint;
   if (!response?.id) {
     // Permission template path returns no call id. Mirror the header button and
     // surface whether the request was just sent or is already pending instead of

app/javascript/dashboard/components-next/Conversation/ConversationCard/ConversationCard.vue

@@ -48,8 +48,8 @@ const inbox = computed(() => props.stateInbox);
 const inboxName = computed(() => inbox.value?.name);
 
 const inboxIcon = computed(() => {
-  const { channelType, medium, voiceEnabled } = inbox.value;
-  return getInboxIconByType(channelType, medium, 'fill', voiceEnabled);
+  const { channelType, medium } = inbox.value;
+  return getInboxIconByType(channelType, medium);
 });
 
 const lastActivityAt = computed(() => {

app/javascript/dashboard/components-next/Inbox/InboxCard.vue

@@ -49,8 +49,8 @@ const isUnread = computed(() => !props.inboxItem?.readAt);
 const inbox = computed(() => props.stateInbox);
 
 const inboxIcon = computed(() => {
-  const { channelType, medium, voiceEnabled } = inbox.value;
-  return getInboxIconByType(channelType, medium, 'fill', voiceEnabled);
+  const { channelType, medium } = inbox.value;
+  return getInboxIconByType(channelType, medium);
 });
 
 const hasSlaThreshold = computed(() => {

app/javascript/dashboard/components-next/NewConversation/ComposeConversation.vue

@@ -234,7 +234,6 @@ onMounted(() => resetContacts());
     ref="popoverRef"
     :align="align"
     :show-content-border="false"
-    :close-on-scroll="false"
     @show="onPopoverShow"
     @hide="onPopoverHide"
   >

app/javascript/dashboard/components-next/NewConversation/helpers/composeConversationHelper.js

@@ -37,11 +37,10 @@ const transformInbox = ({
   channelType,
   phoneNumber,
   medium,
-  voiceEnabled,
   ...rest
 }) => ({
   id,
-  icon: getInboxIconByType(channelType, medium, 'line', voiceEnabled),
+  icon: getInboxIconByType(channelType, medium, 'line'),
   label: generateLabelForContactableInboxesList({
     name,
     email,
@@ -55,7 +54,6 @@ const transformInbox = ({
   phoneNumber,
   channelType,
   medium,
-  voiceEnabled,
   ...rest,
 });
 

app/javascript/dashboard/components-next/NewConversation/helpers/specs/composeConversationHelper.spec.js

@@ -79,20 +79,6 @@ describe('composeConversationHelper', () => {
         channelType: INBOX_TYPES.EMAIL,
       });
     });
-
-    it('uses the voice glyph for a voice-enabled inbox', () => {
-      const inboxes = [
-        {
-          id: 2,
-          name: 'WhatsApp Cloud',
-          channelType: INBOX_TYPES.WHATSAPP,
-          voiceEnabled: true,
-        },
-      ];
-
-      const result = helpers.buildContactableInboxesList(inboxes);
-      expect(result[0].icon).toBe('i-woot-whatsapp-voice');
-    });
   });
 
   describe('getCapitalizedNameFromEmail', () => {

app/javascript/dashboard/components-next/audio/AudioPlayer.vue

@@ -117,8 +117,8 @@ const downloadRecording = () => {
     >
       <template #icon>
         <Icon
-          :icon="isPlaying ? 'i-woot-audio-pause' : 'i-woot-audio-play'"
-          class="size-4 flex-shrink-0 text-n-slate-11"
+          :icon="isPlaying ? 'i-lucide-pause' : 'i-lucide-play'"
+          class="size-4 flex-shrink-0"
         />
       </template>
     </Button>
@@ -127,10 +127,10 @@ const downloadRecording = () => {
       min="0"
       :max="duration || 0"
       :value="currentTime"
-      class="flex-1 min-w-0 lg:grow-0 lg:basis-24 h-0.5 rounded-full appearance-none cursor-pointer bg-n-slate-12/30 [&::-webkit-slider-thumb]:appearance-none [&::-webkit-slider-thumb]:size-2 [&::-webkit-slider-thumb]:rounded-full [&::-webkit-slider-thumb]:bg-n-slate-11 [&::-moz-range-thumb]:appearance-none [&::-moz-range-thumb]:size-2 [&::-moz-range-thumb]:border-0 [&::-moz-range-thumb]:rounded-full [&::-moz-range-thumb]:bg-n-slate-11"
+      class="flex-1 min-w-0 lg:grow-0 lg:basis-24 h-1 rounded-lg appearance-none cursor-pointer bg-n-slate-12/30 accent-n-slate-11"
       @input="seek"
     />
-    <span class="text-label-small tabular-nums text-n-slate-11 shrink-0">
+    <span class="text-sm tabular-nums text-n-slate-11 shrink-0">
       {{ displayedTime }}
     </span>
     <div class="w-px h-3.5 bg-n-slate-6 shrink-0" />

app/javascript/dashboard/components-next/captain/assistant/InboxCard.vue

@@ -58,12 +58,8 @@ const menuItems = computed(() => [
 ]);
 
 const icon = computed(() => {
-  const {
-    medium,
-    channel_type: type,
-    voice_enabled: voiceEnabled,
-  } = props.inbox;
-  return getInboxIconByType(type, medium, 'outline', voiceEnabled);
+  const { medium, channel_type: type } = props.inbox;
+  return getInboxIconByType(type, medium, 'outline');
 });
 
 const handleAction = ({ action, value }) => {

app/javascript/dashboard/components-next/captain/pageComponents/overview/MetricCard.vue

@@ -9,7 +9,6 @@ const props = defineProps({
   // null = neutral, true = good direction, false = bad direction
   trendGood: { type: Boolean, default: null },
   clickable: { type: Boolean, default: false },
-  loading: { type: Boolean, default: false },
 });
 
 const emit = defineEmits(['click']);
@@ -46,11 +45,7 @@ const onActivate = () => {
         class="transition-opacity opacity-0 cursor-help i-lucide-info size-3.5 text-n-slate-10 group-hover:opacity-100"
       />
     </div>
-    <div v-if="loading" class="flex items-end justify-between gap-2">
-      <div class="w-20 rounded h-9 bg-n-slate-3 animate-pulse" />
-      <div class="w-10 h-5 rounded bg-n-slate-3 animate-pulse" />
-    </div>
-    <div v-else class="flex items-end justify-between gap-2">
+    <div class="flex items-end justify-between gap-2">
       <span
         class="text-3xl font-semibold tracking-tight tabular-nums text-n-slate-12"
       >

app/javascript/dashboard/components-next/captain/pageComponents/overview/WelcomeCard.vue

@@ -9,10 +9,6 @@ const props = defineProps({
     type: String,
     default: '30',
   },
-  stats: {
-    type: Object,
-    default: null,
-  },
 });
 
 const route = useRoute();
@@ -24,41 +20,22 @@ const assistantId = computed(() => route.params.assistantId);
 const welcomeMarkdown = ref('');
 const isLoading = ref(false);
 
-// Increments on every fetch so a slow response for a superseded
-// range/stats/assistant can't overwrite the latest request's state.
-let fetchToken = 0;
-
 const fetchSummary = async () => {
-  fetchToken += 1;
-  const token = fetchToken;
-
-  if (!props.stats) {
-    welcomeMarkdown.value = '';
-    isLoading.value = false;
-    return;
-  }
-
   isLoading.value = true;
-  let message = '';
   try {
     const { data } = await CaptainAssistant.getSummary({
       assistantId: assistantId.value,
       range: props.range,
-      stats: props.stats,
     });
-    message = data.message ?? '';
+    welcomeMarkdown.value = data.message ?? '';
   } catch {
-    message = '';
+    welcomeMarkdown.value = '';
+  } finally {
+    isLoading.value = false;
   }
-
-  if (token !== fetchToken) return;
-  welcomeMarkdown.value = message;
-  isLoading.value = false;
 };
 
-watch([() => props.range, () => props.stats, assistantId], fetchSummary, {
-  immediate: true,
-});
+watch([() => props.range, assistantId], fetchSummary, { immediate: true });
 
 // Render through the shared markdown formatter (html disabled, so it is safe)
 // used everywhere else for Captain output, instead of a bespoke parser. It

app/javascript/dashboard/components-next/icon/ChannelIcon.vue

@@ -1,5 +1,6 @@
 <script setup>
 import { computed, toRef } from 'vue';
+import { isVoiceCallEnabled } from 'dashboard/helper/inbox';
 import { useChannelIcon, useChannelBrandIcon } from './provider';
 import Icon from 'next/icon/Icon.vue';
 
@@ -20,6 +21,7 @@ defineOptions({ inheritAttrs: false });
 
 const inboxRef = toRef(props, 'inbox');
 
+const hasVoiceBadge = computed(() => isVoiceCallEnabled(props.inbox));
 const channelIcon = useChannelIcon(inboxRef);
 const brandIcon = useChannelBrandIcon(inboxRef);
 
@@ -29,7 +31,13 @@ const icon = computed(() =>
 </script>
 
 <template>
-  <span class="inline-flex" v-bind="$attrs">
+  <span class="relative inline-flex" v-bind="$attrs">
     <Icon :icon="icon" class="size-full" />
+    <span
+      v-if="hasVoiceBadge"
+      class="absolute top-0 ltr:right-0 rtl:left-0 inline-flex items-center justify-center size-2 rounded-full bg-n-surface-1"
+    >
+      <Icon icon="i-lucide-audio-lines" class="size-1.5 text-n-slate-12" />
+    </span>
   </span>
 </template>

app/javascript/dashboard/components-next/icon/provider.js

@@ -1,9 +1,4 @@
-import {
-  INBOX_TYPES,
-  TWILIO_CHANNEL_MEDIUM,
-  isVoiceCallEnabled,
-  getInboxVoiceIcon,
-} from 'dashboard/helper/inbox';
+import { INBOX_TYPES, TWILIO_CHANNEL_MEDIUM } from 'dashboard/helper/inbox';
 import { computed } from 'vue';
 
 const channelTypeIconMap = {
@@ -66,9 +61,16 @@ export function useChannelIcon(inbox) {
       icon = 'i-woot-whatsapp';
     }
 
-    // Voice-enabled inboxes use the combined channel + voice-wave badge glyph.
-    if (isVoiceCallEnabled(inboxDetails)) {
-      icon = getInboxVoiceIcon(type, inboxDetails.medium);
+    // Native Twilio voice inbox: a TwilioSms with voice enabled (and no WhatsApp medium)
+    // is presented as a Voice channel, so show the phone icon.
+    const voiceEnabled =
+      inboxDetails.voice_enabled || inboxDetails.voiceEnabled;
+    if (
+      type === INBOX_TYPES.TWILIO &&
+      voiceEnabled &&
+      inboxDetails.medium !== TWILIO_CHANNEL_MEDIUM.WHATSAPP
+    ) {
+      icon = 'i-woot-voice';
     }
 
     return icon ?? 'i-ri-global-fill';

app/javascript/dashboard/components-next/icon/specs/provider.spec.js

@@ -19,32 +19,13 @@ describe('useChannelIcon', () => {
     expect(icon).toBe('i-woot-whatsapp');
   });
 
-  it('returns the voice-call glyph for a voice-enabled Twilio channel', () => {
+  it('returns correct icon for voice-enabled Twilio channel', () => {
     const inbox = {
       channel_type: 'Channel::TwilioSms',
       voice_enabled: true,
     };
     const { value: icon } = useChannelIcon(inbox);
-    expect(icon).toBe('i-woot-voice-call');
-  });
-
-  it('returns the WhatsApp voice glyph for a voice-enabled WhatsApp channel', () => {
-    const inbox = {
-      channel_type: 'Channel::Whatsapp',
-      voice_enabled: true,
-    };
-    const { value: icon } = useChannelIcon(inbox);
-    expect(icon).toBe('i-woot-whatsapp-voice');
-  });
-
-  it('returns the WhatsApp voice glyph for a voice-enabled Twilio WhatsApp channel', () => {
-    const inbox = {
-      channel_type: 'Channel::TwilioSms',
-      medium: 'whatsapp',
-      voice_enabled: true,
-    };
-    const { value: icon } = useChannelIcon(inbox);
-    expect(icon).toBe('i-woot-whatsapp-voice');
+    expect(icon).toBe('i-woot-voice');
   });
 
   it('returns correct icon for Line channel', () => {

app/javascript/dashboard/components-next/message/CaptainGenerationDetails.vue

@@ -1,342 +0,0 @@
-<script setup>
-import { computed, ref } from 'vue';
-import { useI18n, I18nT } from 'vue-i18n';
-import Icon from 'dashboard/components-next/icon/Icon.vue';
-import Popover from 'dashboard/components-next/popover/Popover.vue';
-import { useStore, useMapGetter } from 'dashboard/composables/store';
-import { useAccount } from 'dashboard/composables/useAccount';
-import { FEATURE_FLAGS } from 'dashboard/featureFlags';
-import { useMessageContext } from './provider.js';
-import { MESSAGE_VARIANTS, ORIENTATION } from './constants';
-
-const props = defineProps({
-  messageId: { type: Number, required: true },
-});
-
-const { t } = useI18n();
-const { orientation, variant, createdAt } = useMessageContext();
-const store = useStore();
-const { isCloudFeatureEnabled } = useAccount();
-
-const isOpen = ref(false);
-
-const showSparkle = computed(() =>
-  isCloudFeatureEnabled(FEATURE_FLAGS.CAPTAIN_V2)
-);
-
-const session = computed(() =>
-  store.getters['captainAgentSessions/getSessionByMessageId'](props.messageId)
-);
-const hasFetched = computed(() =>
-  store.getters['captainAgentSessions/hasFetched'](props.messageId)
-);
-const isLoading = computed(
-  () =>
-    !hasFetched.value ||
-    store.getters['captainAgentSessions/isFetching'](props.messageId)
-);
-
-const citations = computed(() => session.value?.citations || []);
-
-const scenarioTitles = computed(() =>
-  (session.value?.scenarios || []).reduce((map, scenario) => {
-    map[scenario.id] = scenario.title;
-    return map;
-  }, {})
-);
-
-// Fallback for agents without a matching scenario title:
-// "chatwoot_assistant" → "Chatwoot assistant",
-// "scenario_5_chatwoot_uptime_agent" → "Chatwoot uptime".
-const humanizeAgentName = agentName => {
-  const label = agentName
-    .replace(/^scenario_\d+_/, '')
-    .replace(/_agent$/, '')
-    .replaceAll('_', ' ')
-    .trim();
-  return label.charAt(0).toUpperCase() + label.slice(1);
-};
-
-const handoffLabel = agentName => {
-  const scenarioId = agentName.match(/^scenario_(\d+)/)?.[1];
-  return scenarioTitles.value[scenarioId] || humanizeAgentName(agentName);
-};
-
-const ACRONYMS = ['faq', 'api', 'url', 'id', 'sla', 'csat'];
-
-// Tool names arrive as RubyLLM identifiers like
-// "captain--tools--faq_lookup" or "custom_get_status_page_overview";
-// show "FAQ Lookup" / "Get Status Page Overview" instead.
-const humanizeToolName = name => {
-  return (name || '')
-    .split('--')
-    .pop()
-    .replace(/^custom_/, '')
-    .split('_')
-    .filter(Boolean)
-    .map(word =>
-      ACRONYMS.includes(word)
-        ? word.toUpperCase()
-        : word.charAt(0).toUpperCase() + word.slice(1)
-    )
-    .join(' ');
-};
-
-// Argument keys are camelCased by the store ("labelName"); show "Label Name".
-const humanizeArgumentKey = key =>
-  key
-    .replace(/([a-z])([A-Z])/g, '$1 $2')
-    .split(' ')
-    .map(word => word.charAt(0).toUpperCase() + word.slice(1))
-    .join(' ');
-
-const formatArguments = args => {
-  if (!args || typeof args !== 'object') return '';
-  return Object.entries(args)
-    .map(([key, value]) => `${humanizeArgumentKey(key)}: ${value}`)
-    .join(', ');
-};
-
-// Timeline of what Captain did during the run: tool calls (with their
-// arguments) and scenario/agent handoffs. Message bodies and raw tool
-// results are intentionally not echoed here.
-const steps = computed(() => {
-  const runContext = session.value?.runContext;
-  const result = [];
-  let currentAgent = null;
-
-  (Array.isArray(runContext) ? runContext : []).forEach(entry => {
-    if (entry?.role !== 'assistant') return;
-
-    const agentName = entry.agentName;
-    if (agentName && agentName !== currentAgent) {
-      if (currentAgent !== null) {
-        result.push({ type: 'handoff', name: handoffLabel(agentName) });
-      }
-      currentAgent = agentName;
-    }
-
-    (entry.toolCalls || []).forEach(call => {
-      // Agent-to-agent transfers surface as "handoff_to_<agent>" tool calls;
-      // the agent_name change above already yields a handoff step for them.
-      if (call.name?.startsWith('handoff_to_')) return;
-
-      result.push({
-        type: 'tool',
-        name: humanizeToolName(call.name),
-        detail: formatArguments(call.arguments),
-      });
-    });
-  });
-
-  return result;
-});
-
-// The final assistant entry stores structured content ({response, reasoning});
-// surface the model's reasoning for the reply it produced.
-const reasoning = computed(() => {
-  const runContext = session.value?.runContext;
-  if (!Array.isArray(runContext)) return '';
-
-  const entry = [...runContext]
-    .reverse()
-    .find(item => item?.role === 'assistant' && item.content?.reasoning);
-  return entry?.content?.reasoning || '';
-});
-
-const STEP_ICONS = {
-  tool: 'i-ph-wrench',
-  handoff: 'i-ph-user-switch',
-};
-
-const STEP_KEYPATHS = {
-  tool: 'CONVERSATION.CAPTAIN_GENERATION.STEP_TOOL',
-  handoff: 'CONVERSATION.CAPTAIN_GENERATION.STEP_HANDOFF',
-};
-
-const currentUser = useMapGetter('getCurrentUser');
-const isSuperAdmin = computed(() => currentUser.value.type === 'SuperAdmin');
-
-// Model and credits are only surfaced to super admins and in development.
-const devDetails = computed(() => {
-  if (!session.value) return null;
-  if (!import.meta.env.DEV && !isSuperAdmin.value) return null;
-  const model = t('CONVERSATION.CAPTAIN_GENERATION.MODEL', {
-    model: session.value.llmModel,
-  });
-  const credits = t('CONVERSATION.CAPTAIN_GENERATION.CREDITS', {
-    credits: session.value.creditsConsumed,
-  });
-  return `${model} · ${credits}`;
-});
-
-// With the sparkle at the row start, the meta gets pushed to the opposite end;
-// without it, fall back to the message orientation.
-const rowLayoutClass = computed(() => {
-  if (showSparkle.value) return 'justify-between';
-  return orientation.value === ORIENTATION.LEFT
-    ? 'justify-start'
-    : 'justify-end';
-});
-
-// Blend the sparkle with the bubble background: amber on private notes,
-// slate everywhere else. Tokens adapt to dark mode on their own.
-const sparkleColorClass = computed(() => {
-  if (variant.value === MESSAGE_VARIANTS.PRIVATE) {
-    return isOpen.value
-      ? 'text-n-amber-12/80'
-      : 'text-n-amber-12/40 hover:text-n-amber-12/70';
-  }
-  return isOpen.value
-    ? 'text-n-slate-12'
-    : 'text-n-slate-11/60 hover:text-n-slate-12';
-});
-
-const popoverAlign = computed(() =>
-  orientation.value === ORIENTATION.LEFT ? 'start' : 'end'
-);
-
-const prefetch = () => {
-  store.dispatch('captainAgentSessions/fetch', {
-    messageId: props.messageId,
-    createdAt: createdAt.value,
-  });
-};
-
-const onPopoverShow = () => {
-  isOpen.value = true;
-  prefetch();
-};
-
-const onPopoverHide = () => {
-  isOpen.value = false;
-};
-</script>
-
-<template>
-  <div class="flex items-center gap-1.5" :class="rowLayoutClass">
-    <Popover
-      v-if="showSparkle"
-      :align="popoverAlign"
-      @show="onPopoverShow"
-      @hide="onPopoverHide"
-    >
-      <button
-        v-tooltip="t('CONVERSATION.CAPTAIN_GENERATION.TITLE')"
-        type="button"
-        class="inline-flex items-center gap-1 p-0 bg-transparent border-0 cursor-pointer"
-        :class="sparkleColorClass"
-        @mouseenter="prefetch"
-        @focus="prefetch"
-      >
-        <Icon icon="i-ph-sparkle-fill" class="size-3.5" />
-        <span class="text-xs">
-          {{ t('CONVERSATION.CAPTAIN_GENERATION.GENERATED_BY') }}
-        </span>
-      </button>
-      <template #content>
-        <div class="flex flex-col gap-4 p-4 w-80">
-          <span v-if="isLoading" class="text-xs text-n-slate-11">
-            {{ t('CONVERSATION.CAPTAIN_GENERATION.LOADING') }}
-          </span>
-          <span v-else-if="!session" class="text-xs text-n-slate-11">
-            {{ t('CONVERSATION.CAPTAIN_GENERATION.EMPTY') }}
-          </span>
-          <template v-else>
-            <div v-if="steps.length" class="flex flex-col gap-2">
-              <span class="text-xs font-medium text-n-slate-11">
-                {{ t('CONVERSATION.CAPTAIN_GENERATION.TIMELINE') }}
-              </span>
-              <div class="flex flex-col">
-                <div
-                  v-for="(step, index) in steps"
-                  :key="index"
-                  class="flex gap-2.5"
-                >
-                  <div class="flex flex-col items-center">
-                    <span
-                      class="flex items-center justify-center rounded-full size-5 bg-n-alpha-2 text-n-slate-11"
-                    >
-                      <Icon :icon="STEP_ICONS[step.type]" class="size-3" />
-                    </span>
-                    <span
-                      v-if="index < steps.length - 1"
-                      class="flex-1 w-px min-h-2 bg-n-weak"
-                    />
-                  </div>
-                  <div
-                    class="flex flex-col min-w-0 gap-0.5"
-                    :class="index < steps.length - 1 ? 'pb-3' : ''"
-                  >
-                    <I18nT
-                      :keypath="STEP_KEYPATHS[step.type]"
-                      tag="span"
-                      class="text-xs leading-5 text-n-slate-11"
-                    >
-                      <template #name>
-                        <span class="font-medium text-n-slate-12">
-                          {{ step.name }}
-                        </span>
-                      </template>
-                    </I18nT>
-                    <span
-                      v-if="step.detail"
-                      class="text-xs text-n-slate-11 break-words"
-                    >
-                      {{ step.detail }}
-                    </span>
-                  </div>
-                </div>
-              </div>
-            </div>
-            <div v-if="citations.length" class="flex flex-col gap-2">
-              <div class="flex items-baseline gap-1.5">
-                <span class="text-xs font-medium text-n-slate-11">
-                  {{ t('CONVERSATION.CAPTAIN_GENERATION.SOURCES') }}
-                </span>
-                <span class="text-xs text-n-slate-10">
-                  {{
-                    t(
-                      'CONVERSATION.CAPTAIN_GENERATION.SOURCES_SUMMARY',
-                      citations.length
-                    )
-                  }}
-                </span>
-              </div>
-              <ul class="flex flex-col gap-1 m-0 list-disc ps-4">
-                <li
-                  v-for="citation in citations"
-                  :key="citation.id"
-                  class="text-xs text-n-slate-12"
-                >
-                  <a
-                    v-if="citation.link"
-                    :href="citation.link"
-                    target="_blank"
-                    rel="noopener noreferrer"
-                    class="text-xs text-n-blue-11 hover:underline"
-                  >
-                    {{ citation.title || citation.link }}
-                  </a>
-                  <span v-else>{{ citation.title }}</span>
-                </li>
-              </ul>
-            </div>
-            <div v-if="reasoning" class="flex flex-col gap-2">
-              <span class="text-xs font-medium text-n-slate-11">
-                {{ t('CONVERSATION.CAPTAIN_GENERATION.REASONING') }}
-              </span>
-              <p class="m-0 text-xs leading-normal text-n-slate-12 break-words">
-                {{ reasoning }}
-              </p>
-            </div>
-            <span v-if="devDetails" class="text-xs text-n-slate-11">
-              {{ devDetails }}
-            </span>
-          </template>
-        </div>
-      </template>
-    </Popover>
-    <slot name="meta" />
-  </div>
-</template>

app/javascript/dashboard/components-next/message/Message.vue

@@ -457,11 +457,10 @@ function handleReplyTo() {
 
 const avatarInfo = computed(() => {
   if (props.contentAttributes?.externalEcho) {
-    const { name, avatar_url, channel_type, medium, voice_enabled } =
-      inbox.value;
+    const { name, avatar_url, channel_type, medium } = inbox.value;
     const iconName = avatar_url
       ? null
-      : getInboxIconByType(channel_type, medium, 'fill', voice_enabled);
+      : getInboxIconByType(channel_type, medium);
     return {
       name: iconName ? '' : name || t('CONVERSATION.NATIVE_APP'),
       src: avatar_url || '',

app/javascript/dashboard/components-next/message/bubbles/Base.vue

@@ -2,7 +2,6 @@
 import { computed } from 'vue';
 
 import MessageMeta from '../MessageMeta.vue';
-import CaptainGenerationDetails from '../CaptainGenerationDetails.vue';
 
 import { emitter } from 'shared/helpers/mitt';
 import { useMessageContext } from '../provider.js';
@@ -10,38 +9,16 @@ import { useI18n } from 'vue-i18n';
 
 import MessageFormatter from 'shared/helpers/MessageFormatter.js';
 import { BUS_EVENTS } from 'shared/constants/busEvents';
-import { MESSAGE_VARIANTS, ORIENTATION, SENDER_TYPES } from '../constants';
+import { MESSAGE_VARIANTS, ORIENTATION } from '../constants';
 
 const props = defineProps({
   hideMeta: { type: Boolean, default: false },
 });
 
-const {
-  variant,
-  orientation,
-  inReplyTo,
-  shouldGroupWithNext,
-  id,
-  sender,
-  senderType,
-} = useMessageContext();
+const { variant, orientation, inReplyTo, shouldGroupWithNext } =
+  useMessageContext();
 const { t } = useI18n();
 
-const isCaptainMessage = computed(
-  () =>
-    (sender.value?.type ?? senderType.value) === SENDER_TYPES.CAPTAIN_ASSISTANT
-);
-
-const metaColorClass = computed(() =>
-  variant.value === MESSAGE_VARIANTS.PRIVATE
-    ? 'text-n-amber-12/50'
-    : 'text-n-slate-11'
-);
-
-const emailMetaClass = computed(() =>
-  variant.value === MESSAGE_VARIANTS.EMAIL ? 'px-3 pb-3' : ''
-);
-
 const varaintBaseMap = {
   [MESSAGE_VARIANTS.AGENT]: 'bg-n-solid-blue text-n-slate-12',
   [MESSAGE_VARIANTS.PRIVATE]:
@@ -137,21 +114,16 @@ const replyToPreview = computed(() => {
       />
     </div>
     <slot />
-    <template v-if="shouldShowMeta">
-      <CaptainGenerationDetails
-        v-if="isCaptainMessage"
-        :message-id="id"
-        class="mt-2"
-      >
-        <template #meta>
-          <MessageMeta :class="[emailMetaClass, metaColorClass]" />
-        </template>
-      </CaptainGenerationDetails>
-      <MessageMeta
-        v-else
-        :class="[flexOrientationClass, emailMetaClass, metaColorClass]"
-        class="mt-2"
-      />
-    </template>
+    <MessageMeta
+      v-if="shouldShowMeta"
+      :class="[
+        flexOrientationClass,
+        variant === MESSAGE_VARIANTS.EMAIL ? 'px-3 pb-3' : '',
+        variant === MESSAGE_VARIANTS.PRIVATE
+          ? 'text-n-amber-12/50'
+          : 'text-n-slate-11',
+      ]"
+      class="mt-2"
+    />
   </div>
 </template>

app/javascript/dashboard/components-next/message/bubbles/VoiceCall.vue

@@ -263,9 +263,9 @@ const handleCallBack = async () => {
   if (!canCallBack.value || isInitiatingCall.value) return;
   try {
     if (isWhatsapp.value) {
-      const response = await whatsappCallSession.initiateOutboundCall({
-        conversationId: conversationId.value,
-      });
+      const response = await whatsappCallSession.initiateOutboundCall(
+        conversationId.value
+      );
       if (response?.status === VOICE_CALL_OUTBOUND_INIT_STATUS.LOCKED) return;
       // Permission template path returns no call id — show banner, no widget yet.
       if (!response?.id) {

app/javascript/dashboard/components-next/popover/Popover.vue

@@ -1,11 +1,7 @@
 <script setup>
 import { ref, computed, watch, nextTick } from 'vue';
 import { vOnClickOutside } from '@vueuse/components';
-import {
-  useBreakpoints,
-  breakpointsTailwind,
-  useEventListener,
-} from '@vueuse/core';
+import { useBreakpoints, breakpointsTailwind } from '@vueuse/core';
 import { useDropdownPosition } from 'dashboard/composables/useDropdownPosition';
 import { useKeyboardEvents } from 'dashboard/composables/useKeyboardEvents';
 import TeleportWithDirection from 'dashboard/components-next/TeleportWithDirection.vue';
@@ -20,10 +16,6 @@ const props = defineProps({
     type: Boolean,
     default: false,
   },
-  closeOnScroll: {
-    type: Boolean,
-    default: true,
-  },
   showContentBorder: {
     type: Boolean,
     default: true,
@@ -49,12 +41,8 @@ const { fixedPosition, updatePosition } = useDropdownPosition(
   { align: props.align }
 );
 
-const SCROLL_CLOSE_THRESHOLD = 24;
-const triggerTopAtOpen = ref(0);
-
 const show = async () => {
   isActive.value = true;
-  triggerTopAtOpen.value = triggerRef.value?.getBoundingClientRect().top ?? 0;
   if (!isMobile.value) {
     await nextTick();
     updatePosition();
@@ -68,22 +56,6 @@ const hide = () => {
   emit('hide');
 };
 
-// The teleported popover tracks its trigger while ancestors scroll; allow
-// small drift (trackpad inertia), but close once the trigger moves further.
-useEventListener(
-  window,
-  'scroll',
-  event => {
-    if (!props.closeOnScroll || !showPopover.value) return;
-    if (popoverRef.value?.contains(event.target)) return;
-    const top = triggerRef.value?.getBoundingClientRect().top ?? 0;
-    if (Math.abs(top - triggerTopAtOpen.value) > SCROLL_CLOSE_THRESHOLD) {
-      hide();
-    }
-  },
-  { capture: true, passive: true }
-);
-
 const toggle = async () => {
   if (isActive.value) hide();
   else await show();

app/javascript/dashboard/components/ui/ContextMenu.vue

@@ -77,15 +77,6 @@ const handleClose = () => {
   emit('close');
 };
 
-const handleFocusOut = event => {
-  // Keep the menu open while focus stays inside it (e.g. the label search
-  // input); close it once focus leaves the menu entirely.
-  if (menuRef.value?.contains(event.relatedTarget)) {
-    return;
-  }
-  handleClose();
-};
-
 onUnmounted(() => {
   isLocked.value = false;
 });
@@ -98,7 +89,7 @@ onUnmounted(() => {
       class="fixed outline-none z-[9999] cursor-pointer"
       :style="position"
       tabindex="0"
-      @focusout="handleFocusOut"
+      @blur="handleClose"
     >
       <slot />
     </div>

app/javascript/dashboard/components/widgets/WootWriter/FullEditor.vue

@@ -8,8 +8,6 @@ import {
   EditorState,
   Selection,
   imageResizeView,
-  toggleMark,
-  wrapInList,
 } from '@chatwoot/prosemirror-schema';
 import {
   suggestionsPlugin,
@@ -19,6 +17,8 @@ import imagePastePlugin from '@chatwoot/prosemirror-schema/src/plugins/image';
 import embedPreviewPlugin from '@chatwoot/prosemirror-schema/src/plugins/embedPreview';
 import trailingParagraphPlugin from '@chatwoot/prosemirror-schema/src/plugins/trailingParagraph';
 import { embeds as markdownEmbeds } from 'dashboard/helper/markdownEmbeds';
+import { toggleMark } from 'prosemirror-commands';
+import { wrapInList } from 'prosemirror-schema-list';
 import { toggleBlockType } from '@chatwoot/prosemirror-schema/src/menu/common';
 import { checkFileSizeLimit } from 'shared/helpers/FileHelper';
 import { isEscape } from 'shared/helpers/KeyboardHelpers';

app/javascript/dashboard/components/widgets/conversation/ConversationCallButton.vue

@@ -69,9 +69,9 @@ const callButtonTooltip = computed(() =>
 const startWhatsappCall = async () => {
   if (whatsappCallSession.isInitiating.value) return;
   try {
-    const response = await whatsappCallSession.initiateOutboundCall({
-      conversationId: props.chat.id,
-    });
+    const response = await whatsappCallSession.initiateOutboundCall(
+      props.chat.id
+    );
 
     // Composable returns LOCKED when init is already in flight or a call is
     // active; soft no-op so a parallel click doesn't trigger a banner.

app/javascript/dashboard/components/widgets/conversation/MessagesView.vue

@@ -33,7 +33,9 @@ import {
 // constants
 import { BUS_EVENTS } from 'shared/constants/busEvents';
 import { REPLY_POLICY } from 'shared/constants/links';
-import wootConstants from 'dashboard/constants/globals';
+import wootConstants, {
+  META_RESTRICTION_STATUS_URL,
+} from 'dashboard/constants/globals';
 import { LOCAL_STORAGE_KEYS } from 'dashboard/constants/localStorage';
 import { INBOX_TYPES } from 'dashboard/helper/inbox';
 
@@ -93,6 +95,7 @@ export default {
       currentUserId: 'getCurrentUserID',
       listLoadingStatus: 'getAllMessagesLoaded',
       currentAccountId: 'getCurrentAccountId',
+      isOnChatwootCloud: 'globalConfig/isOnChatwootCloud',
     }),
     isOpen() {
       return this.currentChat?.status === wootConstants.STATUS_TYPE.OPEN;
@@ -170,6 +173,13 @@ export default {
         instagramInbox
       );
     },
+    isInstagramRestrictionBannerVisible() {
+      return this.isOnChatwootCloud && this.isAnInstagramChannel;
+    },
+    instagramRestrictionStatusUrl() {
+      return META_RESTRICTION_STATUS_URL;
+    },
+
     replyWindowBannerMessage() {
       if (this.isAWhatsAppChannel) {
         return this.$t('CONVERSATION.TWILIO_WHATSAPP_CAN_REPLY');
@@ -454,7 +464,15 @@ export default {
   >
     <div ref="topBannerRef">
       <Banner
-        v-if="!currentChat.can_reply"
+        v-if="isInstagramRestrictionBannerVisible"
+        color-scheme="warning"
+        class="mx-2 mt-2 overflow-hidden rounded-lg"
+        :banner-message="$t('CONVERSATION.INSTAGRAM_RESTRICTION_BANNER')"
+        :href-link="instagramRestrictionStatusUrl"
+        :href-link-text="$t('CONVERSATION.INSTAGRAM_RESTRICTION_STATUS_LINK')"
+      />
+      <Banner
+        v-else-if="!currentChat.can_reply"
         color-scheme="alert"
         class="mx-2 mt-2 overflow-hidden rounded-lg"
         :banner-message="replyWindowBannerMessage"

app/javascript/dashboard/components/widgets/conversation/contextMenu/Index.vue

@@ -7,13 +7,10 @@ import {
   getSortedAgentsByAvailability,
   getAgentsByUpdatedPresence,
 } from 'dashboard/helper/agentHelper.js';
-import { picoSearch } from '@scmmishra/pico-search';
 import MenuItem from './menuItem.vue';
 import MenuItemWithSubmenu from './menuItemWithSubmenu.vue';
 import wootConstants from 'dashboard/constants/globals';
 import AgentLoadingPlaceholder from './agentLoadingPlaceholder.vue';
-import NextInput from 'dashboard/components-next/input/Input.vue';
-import Icon from 'dashboard/components-next/icon/Icon.vue';
 
 const MENU = {
   MARK_AS_READ: 'mark-as-read',
@@ -34,8 +31,6 @@ export default {
     MenuItem,
     MenuItemWithSubmenu,
     AgentLoadingPlaceholder,
-    NextInput,
-    Icon,
   },
   props: {
     chatId: {
@@ -92,7 +87,6 @@ export default {
   data() {
     return {
       MENU,
-      labelSearchQuery: '',
       STATUS_TYPE: wootConstants.STATUS_TYPE,
       readOption: {
         label: this.$t('CONVERSATION.CARD_CONTEXT_MENU.MARK_AS_READ'),
@@ -222,14 +216,6 @@ export default {
       // Don't show snooze if the conversation is already snoozed/resolved/pending
       return this.status === wootConstants.STATUS_TYPE.OPEN;
     },
-    filteredLabels() {
-      const labels = this.labelSearchQuery
-        ? picoSearch(this.labels, this.labelSearchQuery, ['title'])
-        : this.labels;
-      // Assigned labels first, keeping each group's existing order.
-      const isAssigned = label => this.conversationLabels.includes(label.title);
-      return [...labels].sort((a, b) => isAssigned(b) - isAssigned(a));
-    },
   },
   mounted() {
     this.$store.dispatch('inboxAssignableAgents/fetch', [this.inboxId]);
@@ -349,49 +335,21 @@ export default {
         :option="labelMenuConfig"
         :sub-menu-available="!!labels.length"
       >
-        <div class="pb-1 w-[12.5rem]">
-          <NextInput
-            v-model="labelSearchQuery"
-            type="search"
-            size="sm"
-            class="w-full"
-            custom-input-class="!ps-8 !text-xs"
-            :placeholder="$t('CONVERSATION.CARD_CONTEXT_MENU.SEARCH_LABELS')"
-            @click.stop
-            @keydown.stop
-          >
-            <template #prefix>
-              <Icon
-                icon="i-lucide-search"
-                class="absolute z-10 -translate-y-1/2 pointer-events-none size-3.5 text-n-slate-10 top-1/2 start-2"
-              />
-            </template>
-          </NextInput>
-        </div>
-        <div class="overflow-x-hidden overflow-y-auto max-h-[12.5rem]">
-          <MenuItem
-            v-for="label in filteredLabels"
-            :key="label.id"
-            :option="generateMenuLabelConfig(label, 'label')"
-            :variant="
-              conversationLabels.includes(label.title)
-                ? 'label-assigned'
-                : 'label'
-            "
-            @mousedown.prevent
-            @click.stop="
-              conversationLabels.includes(label.title)
-                ? $emit('removeLabel', label)
-                : $emit('assignLabel', label)
-            "
-          />
-          <p
-            v-if="!filteredLabels.length"
-            class="px-2 py-2 m-0 text-xs text-center text-n-slate-11"
-          >
-            {{ $t('CONVERSATION.CARD_CONTEXT_MENU.NO_LABELS_FOUND') }}
-          </p>
-        </div>
+        <MenuItem
+          v-for="label in labels"
+          :key="label.id"
+          :option="generateMenuLabelConfig(label, 'label')"
+          :variant="
+            conversationLabels.includes(label.title)
+              ? 'label-assigned'
+              : 'label'
+          "
+          @click.stop="
+            conversationLabels.includes(label.title)
+              ? $emit('removeLabel', label)
+              : $emit('assignLabel', label)
+          "
+        />
       </MenuItemWithSubmenu>
       <MenuItemWithSubmenu
         v-if="isAllowed([MENU.AGENT])"

app/javascript/dashboard/components/widgets/conversation/contextMenu/menuItem.vue

@@ -15,7 +15,7 @@ defineProps({
 </script>
 
 <template>
-  <div class="menu group text-n-slate-12 min-h-7 min-w-0" role="button">
+  <div class="menu text-n-slate-12 min-h-7 min-w-0" role="button">
     <fluent-icon
       v-if="variant === 'icon' && option.icon"
       :icon="option.icon"
@@ -52,7 +52,7 @@ defineProps({
     <Icon
       v-if="variant === 'label-assigned'"
       icon="i-lucide-check"
-      class="flex-shrink-0 size-3.5 text-n-brand group-hover:text-white"
+      class="flex-shrink-0 size-3.5 mr-1"
     />
   </div>
 </template>

app/javascript/dashboard/composables/spec/useAgentsList.spec.js

@@ -1,9 +1,9 @@
-import { useMapGetter } from 'dashboard/composables/store';
-import * as agentHelper from 'dashboard/helper/agentHelper';
-import { beforeEach, describe, expect, it, vi } from 'vitest';
 import { ref } from 'vue';
+import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { useAgentsList } from '../useAgentsList';
+import { useMapGetter } from 'dashboard/composables/store';
 import { allAgentsData, formattedAgentsData } from './fixtures/agentFixtures';
+import * as agentHelper from 'dashboard/helper/agentHelper';
 
 // Mock vue-i18n
 vi.mock('vue-i18n', () => ({
@@ -94,32 +94,6 @@ describe('useAgentsList', () => {
     expect(agentsList.value.length).toBe(formattedAgentsData.slice(1).length);
   });
 
-  it('keeps nameless agent bots and applies a fallback label', () => {
-    const namelessBot = {
-      id: 91,
-      name: null,
-      assignee_type: 'AgentBot',
-      availability_status: 'offline',
-    };
-    mockUseMapGetter({
-      'inboxAssignableAgents/getAssignableAgents': ref(() => [
-        ...allAgentsData,
-        namelessBot,
-      ]),
-    });
-
-    const { agentsList } = useAgentsList();
-    // access the computed to trigger evaluation
-    expect(agentsList.value).toBeDefined();
-
-    const passedAgents =
-      agentHelper.getAgentsByUpdatedPresence.mock.calls[0][0];
-    expect(passedAgents).toContainEqual({
-      ...namelessBot,
-      name: '-',
-    });
-  });
-
   it('handles empty assignable agents', () => {
     mockUseMapGetter({
       'inboxAssignableAgents/getAssignableAgents': ref(() => []),

app/javascript/dashboard/composables/useAgentsList.js

@@ -1,10 +1,10 @@
+import { computed } from 'vue';
 import { useMapGetter } from 'dashboard/composables/store';
+import { useI18n } from 'vue-i18n';
 import {
   getAgentsByUpdatedPresence,
   getSortedAgentsByAvailability,
 } from 'dashboard/helper/agentHelper';
-import { computed } from 'vue';
-import { useI18n } from 'vue-i18n';
 
 /**
  * A composable function that provides a list of agents for assignment.
@@ -53,11 +53,7 @@ export function useAgentsList(
    * @type {import('vue').ComputedRef<Array>}
    */
   const agentsList = computed(() => {
-    const agents = (assignableAgents.value || []).map(agent =>
-      !agent.name && agent.assignee_type === 'AgentBot'
-        ? { ...agent, name: '-' }
-        : agent
-    );
+    const agents = assignableAgents.value || [];
     const agentsByUpdatedPresence = getAgentsByUpdatedPresence(
       agents,
       currentUser.value,

app/javascript/dashboard/composables/useWhatsappCallSession.js

@@ -308,8 +308,7 @@ export function useWhatsappCallSession() {
     }
   };
 
-  // target: { conversationId } or { contactId, inboxId }
-  const initiateOutboundCall = async target => {
+  const initiateOutboundCall = async conversationId => {
     // Module-scoped lock + active-session guard so a second click — from the
     // same composable instance OR a different one (header vs contact panel)
     // OR while a call is already live — can't tear down the in-flight setup
@@ -321,7 +320,10 @@ export function useWhatsappCallSession() {
     isInitiatingOutbound.value = true;
     try {
       const sdpOffer = await prepareOutboundOffer();
-      const response = await WhatsappCallsAPI.initiate(target, sdpOffer);
+      const response = await WhatsappCallsAPI.initiate(
+        conversationId,
+        sdpOffer
+      );
       if (response?.id) {
         activeCallId = response.id;
         // A connect webhook that raced ahead of this response was buffered;
@@ -352,7 +354,7 @@ export function useWhatsappCallSession() {
         data?.status === VOICE_CALL_OUTBOUND_INIT_STATUS.PERMISSION_REQUESTED ||
         data?.status === VOICE_CALL_OUTBOUND_INIT_STATUS.PERMISSION_PENDING
       ) {
-        return { status: data.status, conversation_id: data.conversation_id };
+        return { status: data.status };
       }
       throw e;
     } finally {

app/javascript/dashboard/constants/globals.js

@@ -78,3 +78,5 @@ export default {
   },
 };
 export const DEFAULT_REDIRECT_URL = '/app/';
+export const META_RESTRICTION_STATUS_URL =
+  'https://status.chatwoot.com/incident/948346';

app/javascript/dashboard/featureFlags.js

@@ -7,7 +7,8 @@ export const FEATURE_FLAGS = {
   AUTOMATIONS: 'automations',
   CAMPAIGNS: 'campaigns',
   WHATSAPP_CAMPAIGNS: 'whatsapp_campaign',
-  WHATSAPP_EMBEDDED_SIGNUP_FLOW: 'whatsapp_embedded_signup_inbox_creation',
+  WHATSAPP_EMBEDDED_SIGNUP_INBOX_CREATION:
+    'whatsapp_embedded_signup_inbox_creation',
   WHATSAPP_MANUAL_TRANSFER: 'whatsapp_manual_transfer',
   WHATSAPP_RECONFIGURE: 'whatsapp_reconfigure',
   CANNED_RESPONSES: 'canned_responses',

app/javascript/dashboard/helper/agentHelper.js

@@ -7,7 +7,7 @@
 export const getAgentsByAvailability = (agents, availability) => {
   return agents
     .filter(agent => agent.availability_status === availability)
-    .sort((a, b) => (a.name || '').localeCompare(b.name || ''));
+    .sort((a, b) => a.name.localeCompare(b.name));
 };
 
 /**

app/javascript/dashboard/helper/editorHelper.js

@@ -1,6 +1,4 @@
 import {
-  InputRule,
-  inputRules,
   MessageMarkdownSerializer,
   MessageMarkdownTransformer,
   messageSchema,
@@ -11,6 +9,7 @@ import * as Sentry from '@sentry/vue';
 import camelcaseKeys from 'camelcase-keys';
 import { FORMATTING, MARKDOWN_PATTERNS } from 'dashboard/constants/editor';
 import { INBOX_TYPES, TWILIO_CHANNEL_MEDIUM } from 'dashboard/helper/inbox';
+import { InputRule, inputRules } from 'prosemirror-inputrules';
 
 /**
  * Extract text from markdown, and remove all images, code blocks, links, headers, bold, italic, lists etc.

app/javascript/dashboard/helper/inbox.js

@@ -55,30 +55,11 @@ export const getVoiceCallProvider = inbox => {
 
 export const isVoiceCallEnabled = inbox => getVoiceCallProvider(inbox) !== null;
 
-// Combined channel + voice-wave badge glyph per voice-call provider.
-export const VOICE_CALL_ICONS = {
-  [VOICE_CALL_PROVIDERS.WHATSAPP]: 'i-woot-whatsapp-voice',
-  [VOICE_CALL_PROVIDERS.TWILIO]: 'i-woot-voice-call',
-};
-
-export const getVoiceCallIcon = provider =>
-  VOICE_CALL_ICONS[provider] ?? VOICE_CALL_ICONS[VOICE_CALL_PROVIDERS.TWILIO];
-
 export const TWILIO_CHANNEL_MEDIUM = {
   WHATSAPP: 'whatsapp',
   SMS: 'sms',
 };
 
-export const getInboxVoiceIcon = (channelType, medium) => {
-  const isWhatsapp =
-    channelType === INBOX_TYPES.WHATSAPP ||
-    (channelType === INBOX_TYPES.TWILIO &&
-      medium === TWILIO_CHANNEL_MEDIUM.WHATSAPP);
-  return getVoiceCallIcon(
-    isWhatsapp ? VOICE_CALL_PROVIDERS.WHATSAPP : VOICE_CALL_PROVIDERS.TWILIO
-  );
-};
-
 const INBOX_ICON_MAP_FILL = {
   [INBOX_TYPES.WEB]: 'i-ri-global-fill',
   [INBOX_TYPES.FB]: 'i-ri-messenger-fill',
@@ -201,14 +182,7 @@ export const getInboxClassByType = (type, phoneNumber) => {
   }
 };
 
-export const getInboxIconByType = (
-  type,
-  medium,
-  variant = 'fill',
-  voiceEnabled = false
-) => {
-  if (voiceEnabled) return getInboxVoiceIcon(type, medium);
-
+export const getInboxIconByType = (type, medium, variant = 'fill') => {
   const iconMap =
     variant === 'fill' ? INBOX_ICON_MAP_FILL : INBOX_ICON_MAP_LINE;
   const defaultIcon =

app/javascript/dashboard/helper/specs/agentHelper.spec.js

@@ -26,18 +26,6 @@ describe('agentHelper', () => {
         offlineAgentsData
       );
     });
-
-    it('does not throw when an agent has a null name', () => {
-      const agents = [
-        { id: 1, name: null, availability_status: 'offline' },
-        { id: 2, name: 'Zoe', availability_status: 'offline' },
-      ];
-
-      expect(() => getAgentsByAvailability(agents, 'offline')).not.toThrow();
-      expect(
-        getAgentsByAvailability(agents, 'offline').map(agent => agent.id)
-      ).toEqual([1, 2]);
-    });
   });
 
   describe('getSortedAgentsByAvailability', () => {

app/javascript/dashboard/helper/specs/inbox.spec.js

@@ -1,11 +1,8 @@
 import {
   INBOX_TYPES,
-  VOICE_CALL_PROVIDERS,
   getInboxClassByType,
   getInboxIconByType,
-  getInboxVoiceIcon,
   getInboxWarningIconClass,
-  getVoiceCallIcon,
 } from '../inbox';
 
 describe('#Inbox Helpers', () => {
@@ -169,63 +166,4 @@ describe('#Inbox Helpers', () => {
       );
     });
   });
-
-  describe('getVoiceCallIcon', () => {
-    it('returns the WhatsApp voice glyph for the whatsapp provider', () => {
-      expect(getVoiceCallIcon(VOICE_CALL_PROVIDERS.WHATSAPP)).toBe(
-        'i-woot-whatsapp-voice'
-      );
-    });
-
-    it('returns the generic voice-call glyph for the twilio provider', () => {
-      expect(getVoiceCallIcon(VOICE_CALL_PROVIDERS.TWILIO)).toBe(
-        'i-woot-voice-call'
-      );
-    });
-
-    it('falls back to the generic voice-call glyph for an unknown provider', () => {
-      expect(getVoiceCallIcon('unknown')).toBe('i-woot-voice-call');
-      expect(getVoiceCallIcon(undefined)).toBe('i-woot-voice-call');
-    });
-  });
-
-  describe('getInboxVoiceIcon', () => {
-    it('returns the WhatsApp voice glyph for a WhatsApp inbox', () => {
-      expect(getInboxVoiceIcon(INBOX_TYPES.WHATSAPP)).toBe(
-        'i-woot-whatsapp-voice'
-      );
-    });
-
-    it('returns the WhatsApp voice glyph for a Twilio WhatsApp inbox', () => {
-      expect(getInboxVoiceIcon(INBOX_TYPES.TWILIO, 'whatsapp')).toBe(
-        'i-woot-whatsapp-voice'
-      );
-    });
-
-    it('returns the generic voice-call glyph for a Twilio voice inbox', () => {
-      expect(getInboxVoiceIcon(INBOX_TYPES.TWILIO, 'sms')).toBe(
-        'i-woot-voice-call'
-      );
-    });
-  });
-
-  describe('getInboxIconByType with voice enabled', () => {
-    it('returns the WhatsApp voice glyph for a voice-enabled WhatsApp inbox', () => {
-      expect(
-        getInboxIconByType(INBOX_TYPES.WHATSAPP, undefined, 'line', true)
-      ).toBe('i-woot-whatsapp-voice');
-    });
-
-    it('returns the generic voice-call glyph for a voice-enabled Twilio inbox', () => {
-      expect(getInboxIconByType(INBOX_TYPES.TWILIO, 'sms', 'line', true)).toBe(
-        'i-woot-voice-call'
-      );
-    });
-
-    it('returns the normal channel icon when voice is not enabled', () => {
-      expect(
-        getInboxIconByType(INBOX_TYPES.WHATSAPP, undefined, 'line', false)
-      ).toBe('i-woot-whatsapp');
-    });
-  });
 });

app/javascript/dashboard/i18n/locale/en/conversation.json

@@ -44,6 +44,8 @@
     "TWILIO_WHATSAPP_CAN_REPLY": "You can only reply to this conversation using a template message due to",
     "TWILIO_WHATSAPP_24_HOURS_WINDOW": "24 hour message window restriction",
     "OLD_INSTAGRAM_INBOX_REPLY_BANNER": "This Instagram account was migrated to the new Instagram channel inbox. All new messages will show up there. You won’t be able to send messages from this conversation anymore.",
+    "INSTAGRAM_RESTRICTION_BANNER": "Instagram is currently restricted. Some messages or actions may be delayed or unavailable while we restore full support.",
+    "INSTAGRAM_RESTRICTION_STATUS_LINK": "View status update",
     "REPLYING_TO": "You are replying to:",
     "REMOVE_SELECTION": "Remove Selection",
     "DOWNLOAD": "Download",
@@ -70,20 +72,6 @@
     "RATING_TITLE": "Rating",
     "FEEDBACK_TITLE": "Feedback",
     "REPLY_MESSAGE_NOT_FOUND": "Message not available",
-    "CAPTAIN_GENERATION": {
-      "TITLE": "How was this reply generated?",
-      "GENERATED_BY": "Generated by Captain",
-      "LOADING": "Loading details…",
-      "EMPTY": "No generation details available for this message.",
-      "TIMELINE": "Generation steps",
-      "STEP_TOOL": "Called {name}",
-      "STEP_HANDOFF": "Handed off to {name}",
-      "REASONING": "Reasoning",
-      "SOURCES": "Knowledge base",
-      "SOURCES_SUMMARY": "{count} result | {count} results",
-      "MODEL": "Generated with {model}",
-      "CREDITS": "Credits: {credits}"
-    },
     "CARD": {
       "SHOW_LABELS": "Show labels",
       "HIDE_LABELS": "Hide labels",
@@ -193,8 +181,6 @@
       },
       "ASSIGN_AGENT": "Assign agent",
       "ASSIGN_LABEL": "Assign label",
-      "SEARCH_LABELS": "Search labels",
-      "NO_LABELS_FOUND": "No labels found",
       "AGENTS_LOADING": "Loading agents...",
       "ASSIGN_TEAM": "Assign team",
       "DELETE": "Delete conversation",

app/javascript/dashboard/i18n/locale/en/inboxMgmt.json

@@ -58,7 +58,9 @@
         "ERROR_MESSAGE": "There was an error connecting to Instagram, please try again",
         "ERROR_AUTH": "There was an error connecting to Instagram, please try again",
         "NEW_INBOX_SUGGESTION": "This Instagram account was previously linked to a different inbox and has now been migrated here. All new messages will appear here. The old inbox will no longer be able to send or receive messages for this account.",
-        "DUPLICATE_INBOX_BANNER": "This Instagram account was migrated to the new Instagram channel inbox. You won’t be able to send/receive Instagram messages from this inbox anymore."
+        "DUPLICATE_INBOX_BANNER": "This Instagram account was migrated to the new Instagram channel inbox. You won’t be able to send/receive Instagram messages from this inbox anymore.",
+        "SETTINGS_RESTRICTED_WARNING": "Instagram is currently restricted. Some messages or actions may be delayed or unavailable while we restore full support.",
+        "STATUS_LINK": "View status update"
       },
       "TIKTOK": {
         "CONTINUE_WITH_TIKTOK": "Continue with TikTok",

app/javascript/dashboard/modules/search/components/SearchResultConversationItem.vue

@@ -87,8 +87,8 @@ const inboxName = computed(() => props.inbox?.name);
 
 const inboxIcon = computed(() => {
   if (!inbox.value) return null;
-  const { channelType, medium, voiceEnabled } = inbox.value;
-  return getInboxIconByType(channelType, medium, 'fill', voiceEnabled);
+  const { channelType, medium } = inbox.value;
+  return getInboxIconByType(channelType, medium);
 });
 </script>
 

app/javascript/dashboard/modules/search/components/SearchResultMessageItem.vue

@@ -65,8 +65,8 @@ const inboxName = computed(() => inbox.value?.name);
 
 const inboxIcon = computed(() => {
   if (!inbox.value) return null;
-  const { channelType, medium, voiceEnabled } = inbox.value;
-  return getInboxIconByType(channelType, medium, 'fill', voiceEnabled);
+  const { channelType, medium } = inbox.value;
+  return getInboxIconByType(channelType, medium);
 });
 
 const fileAttachments = computed(() => {

app/javascript/dashboard/routes/dashboard/calls/pages/CallsIndex.vue

@@ -1,6 +1,5 @@
 <script setup>
-import { computed, ref, watch, onMounted } from 'vue';
-import { until } from '@vueuse/core';
+import { computed, ref, watch } from 'vue';
 import { useI18n } from 'vue-i18n';
 import { useRoute, useRouter } from 'vue-router';
 import { useMapGetter, useStore } from 'dashboard/composables/store';
@@ -50,9 +49,7 @@ const isVoiceEnabled = computed(
 const calls = computed(() => callHistoryStore.records);
 const meta = computed(() => callHistoryStore.meta);
 const isFetching = computed(() => callHistoryStore.uiFlags.isFetching);
-const accountUiFlags = useMapGetter('accounts/getUIFlags');
-
-const isInitializing = ref(true);
+const inboxesUiFlags = useMapGetter('inboxes/getUIFlags');
 
 // Filters are seeded from the URL so a shared link restores the same view.
 const activity = ref(
@@ -101,25 +98,20 @@ const onPageChange = page => {
   fetchCalls();
 };
 
-onMounted(async () => {
-  try {
-    await Promise.all([
-      store.dispatch('inboxes/get'),
-      until(() => accountUiFlags.value.isFetchingItem).toBe(false),
-    ]);
-    if (!isVoiceEnabled.value) return;
-    // Only admins see the assignee filter, so only they need the agent list.
-    if (isAdmin.value) store.dispatch('agents/get');
-    await fetchCalls();
-  } finally {
-    isInitializing.value = false;
-  }
+// inboxes/get flips isFetching true synchronously, so the spinner shows on the
+// first render and the setup CTA never flashes; hit the calls endpoint only
+// once inboxes confirm voice is on.
+store.dispatch('inboxes/get').then(() => {
+  if (!isVoiceEnabled.value) return;
+  // Only admins see the assignee filter, so only they need the agent list.
+  if (isAdmin.value) store.dispatch('agents/get');
+  fetchCalls();
 });
 </script>
 
 <template>
   <div
-    v-if="isInitializing"
+    v-if="inboxesUiFlags.isFetching"
     class="flex items-center justify-center w-full h-full bg-n-surface-1"
   >
     <Spinner :size="24" />
@@ -129,22 +121,22 @@ onMounted(async () => {
     v-else
     class="flex flex-col w-full h-full overflow-hidden bg-n-surface-1"
   >
-    <header class="shrink-0">
-      <div class="w-full px-6 pt-6">
+    <header class="px-6 pt-6 pb-4 shrink-0">
+      <div class="w-full">
         <h1 class="text-xl font-medium text-n-slate-12">
           {{ t('CALLS_PAGE.HEADER') }}
         </h1>
+        <CallsFilterBar
+          v-model:activity="activity"
+          v-model:assignee-id="assigneeId"
+          v-model:inbox-id="inboxId"
+          class="mt-5"
+          :total-count="isFetching ? null : meta.count"
+          :agents="agents"
+          :inboxes="voiceInboxes"
+          :show-assignee="isAdmin"
+        />
       </div>
-      <CallsFilterBar
-        v-model:activity="activity"
-        v-model:assignee-id="assigneeId"
-        v-model:inbox-id="inboxId"
-        class="mt-5 pb-4 border-b border-n-weak mx-6"
-        :total-count="isFetching ? null : meta.count"
-        :agents="agents"
-        :inboxes="voiceInboxes"
-        :show-assignee="isAdmin"
-      />
     </header>
     <main class="flex-1 px-6 overflow-y-auto">
       <div class="w-full">

app/javascript/dashboard/routes/dashboard/captain/assistants/overview/Index.vue

@@ -1,5 +1,5 @@
 <script setup>
-import { computed, onUnmounted, ref, watch } from 'vue';
+import { computed, ref, watch } from 'vue';
 import { useI18n } from 'vue-i18n';
 import { useRoute } from 'vue-router';
 import { FEATURE_FLAGS } from 'dashboard/featureFlags';
@@ -26,83 +26,21 @@ const canDrilldown = computed(() => checkPermissions(['administrator']));
 const selectedRange = ref('this_month');
 
 const assistantId = computed(() => route.params.assistantId);
-const metricStats = ref(null);
-const faqStats = ref(null);
-const isFetchingMetrics = ref(false);
+const stats = ref(null);
 
-// Increments on every fetch so a response (or retry) from a superseded
-// range/assistant can't clobber the latest request's state.
-let metricsFetchToken = 0;
-let faqStatsFetchToken = 0;
-let metricsAbortController = null;
-let faqStatsAbortController = null;
-
-const fetchMetrics = async () => {
-  metricsFetchToken += 1;
-  const token = metricsFetchToken;
-  metricsAbortController?.abort();
-  metricsAbortController = new AbortController();
-  const { signal } = metricsAbortController;
-  metricStats.value = null;
-  isFetchingMetrics.value = true;
-
-  const requestMetrics = () =>
-    CaptainAssistant.getMetrics({
+const fetchStats = async () => {
+  try {
+    const { data } = await CaptainAssistant.getStats({
       assistantId: assistantId.value,
       range: selectedRange.value,
-      signal,
     });
-
-  let data = null;
-  try {
-    ({ data } = await requestMetrics());
+    stats.value = data;
   } catch {
-    // One silent retry before giving up, unless the request was aborted.
-    try {
-      if (token === metricsFetchToken && !signal.aborted)
-        ({ data } = await requestMetrics());
-    } catch {
-      data = null;
-    }
-  }
-
-  if (token !== metricsFetchToken || signal.aborted) return;
-  metricStats.value = data;
-  isFetchingMetrics.value = false;
-};
-
-const fetchFaqStats = async () => {
-  faqStatsFetchToken += 1;
-  const token = faqStatsFetchToken;
-  faqStatsAbortController?.abort();
-  faqStatsAbortController = new AbortController();
-  const { signal } = faqStatsAbortController;
-  faqStats.value = null;
-
-  try {
-    const { data } = await CaptainAssistant.getFaqStats({
-      assistantId: assistantId.value,
-      signal,
-    });
-    if (token === faqStatsFetchToken && !signal.aborted) faqStats.value = data;
-  } catch {
-    if (token === faqStatsFetchToken && !signal.aborted) faqStats.value = null;
+    stats.value = null;
   }
 };
 
-const summaryStats = computed(() => {
-  if (!metricStats.value || !faqStats.value) return null;
-
-  return { ...metricStats.value, knowledge: faqStats.value };
-});
-
-onUnmounted(() => {
-  metricsAbortController?.abort();
-  faqStatsAbortController?.abort();
-});
-
-watch([selectedRange, assistantId], fetchMetrics, { immediate: true });
-watch(assistantId, fetchFaqStats, { immediate: true });
+watch([selectedRange, assistantId], fetchStats, { immediate: true });
 
 // `direction` says whether a rising trend is good ('up'), bad ('down'), or
 // neutral, so we can colour the delta independently of its sign.
@@ -122,7 +60,7 @@ const formatDuration = hours =>
   hours >= 100 ? `${Math.round(hours / 24)}d` : `${hours}h`;
 
 const metricFor = (statKey, formatValue, direction, trendKind = 'percent') => {
-  const data = metricStats.value?.[statKey];
+  const data = stats.value?.[statKey];
   if (!data) return { value: '—', trend: '', trendGood: null };
 
   const sign = data.trend > 0 ? '+' : '';
@@ -216,9 +154,9 @@ const closeDrilldown = () => {
       <div class="flex flex-col gap-6 pb-8">
         <InboxBanner />
 
-        <CoverageBanner :knowledge="faqStats ?? undefined" />
+        <CoverageBanner :knowledge="stats?.knowledge" />
 
-        <WelcomeCard :range="selectedRange" :stats="summaryStats" />
+        <WelcomeCard :range="selectedRange" />
 
         <div
           class="grid grid-cols-1 gap-px overflow-hidden border rounded-xl sm:grid-cols-2 lg:grid-cols-3 bg-n-weak border-n-weak"
@@ -231,15 +169,12 @@ const closeDrilldown = () => {
             :trend="metric.trend"
             :hint="metric.hint"
             :trend-good="metric.trendGood"
-            :loading="isFetchingMetrics"
-            :clickable="
-              canDrilldown && Boolean(metric.metric) && !isFetchingMetrics
-            "
+            :clickable="canDrilldown && Boolean(metric.metric)"
             @click="openDrilldown(metric)"
           />
         </div>
 
-        <KnowledgeCard :knowledge="faqStats ?? undefined" />
+        <KnowledgeCard :knowledge="stats?.knowledge" />
 
         <QuickLinks />
       </div>

app/javascript/dashboard/routes/dashboard/onboarding/inbox-setup/useChannelConfig.js

@@ -18,7 +18,9 @@ export function useChannelConfig() {
     // app id (not the 'none' sentinel) and the signup configuration id.
     whatsapp: () =>
       (!isOnChatwootCloud.value ||
-        isCloudFeatureEnabled(FEATURE_FLAGS.WHATSAPP_EMBEDDED_SIGNUP_FLOW)) &&
+        isCloudFeatureEnabled(
+          FEATURE_FLAGS.WHATSAPP_EMBEDDED_SIGNUP_INBOX_CREATION
+        )) &&
       Boolean(installationConfig.whatsappAppId) &&
       installationConfig.whatsappAppId !== 'none' &&
       Boolean(installationConfig.whatsappConfigurationId),

app/javascript/dashboard/routes/dashboard/settings/agentBots/Index.vue

@@ -135,7 +135,7 @@ onMounted(() => {
               <BaseTableCell class="max-w-0">
                 <div class="flex items-center gap-4 min-w-0">
                   <Avatar
-                    :name="bot.name || ''"
+                    :name="bot.name"
                     :src="bot.thumbnail"
                     :size="40"
                     class="flex-shrink-0"

app/javascript/dashboard/routes/dashboard/settings/assignmentPolicy/pages/AgentAssignmentEditPage.vue

@@ -79,15 +79,13 @@ const breadcrumbItems = computed(() => {
 });
 
 const buildInboxList = allInboxes =>
-  allInboxes?.map(
-    ({ name, id, email, phoneNumber, channelType, medium, voiceEnabled }) => ({
-      name,
-      id,
-      email,
-      phoneNumber,
-      icon: getInboxIconByType(channelType, medium, 'line', voiceEnabled),
-    })
-  ) || [];
+  allInboxes?.map(({ name, id, email, phoneNumber, channelType, medium }) => ({
+    name,
+    id,
+    email,
+    phoneNumber,
+    icon: getInboxIconByType(channelType, medium, 'line'),
+  })) || [];
 
 const policyInboxes = computed(() =>
   buildInboxList(selectedPolicy.value?.inboxes)

app/javascript/dashboard/routes/dashboard/settings/assignmentPolicy/pages/AgentCapacityEditPage.vue

@@ -64,23 +64,13 @@ const allInboxes = computed(
     inboxes.value
       ?.slice()
       .sort((a, b) => a.name.localeCompare(b.name))
-      .map(
-        ({
-          name,
-          id,
-          email,
-          phoneNumber,
-          channelType,
-          medium,
-          voiceEnabled,
-        }) => ({
-          name,
-          id,
-          email,
-          phoneNumber,
-          icon: getInboxIconByType(channelType, medium, 'line', voiceEnabled),
-        })
-      ) || []
+      .map(({ name, id, email, phoneNumber, channelType, medium }) => ({
+        name,
+        id,
+        email,
+        phoneNumber,
+        icon: getInboxIconByType(channelType, medium, 'line'),
+      })) || []
 );
 
 const formData = computed(() => ({

app/javascript/dashboard/routes/dashboard/settings/assignmentPolicy/pages/components/InboxLinkDialog.vue

@@ -29,8 +29,7 @@ const inboxIcon = computed(() => {
   return getInboxIconByType(
     props.inbox.channelType,
     props.inbox.medium,
-    'line',
-    props.inbox.voiceEnabled
+    'line'
   );
 });
 

app/javascript/dashboard/routes/dashboard/settings/inbox/AddAgents.vue

@@ -103,7 +103,6 @@ export default {
           <label :class="{ error: v$.selectedAgentIds.$error }">
             {{ $t('INBOX_MGMT.ADD.AGENTS.TITLE') }}
             <div
-              data-testid="agent-selector"
               class="rounded-xl outline outline-1 -outline-offset-1 outline-n-weak hover:outline-n-strong px-2 py-2"
             >
               <TagInput

app/javascript/dashboard/routes/dashboard/settings/inbox/Settings.vue

@@ -4,6 +4,8 @@ import { shouldBeUrl } from 'shared/helpers/Validators';
 import { useAlert } from 'dashboard/composables';
 import { useVuelidate } from '@vuelidate/core';
 import Avatar from 'next/avatar/Avatar.vue';
+import Banner from 'dashboard/components-next/banner/Banner.vue';
+import Icon from 'dashboard/components-next/icon/Icon.vue';
 import SettingIntroBanner from 'dashboard/components/widgets/SettingIntroBanner.vue';
 import SettingsToggleSection from 'dashboard/components-next/Settings/SettingsToggleSection.vue';
 import SettingsFieldSection from 'dashboard/components-next/Settings/SettingsFieldSection.vue';
@@ -44,9 +46,11 @@ import SelectInput from 'dashboard/components-next/select/Select.vue';
 import Widget from 'dashboard/modules/widget-preview/components/Widget.vue';
 import AccessToken from 'dashboard/routes/dashboard/settings/profile/AccessToken.vue';
 import { copyTextToClipboard } from 'shared/helpers/clipboard';
+import { META_RESTRICTION_STATUS_URL } from 'dashboard/constants/globals';
 
 export default {
   components: {
+    Banner,
     BotConfiguration,
     CollaboratorsPage,
     ConfigurationPage,
@@ -80,6 +84,7 @@ export default {
     WhatsappManualMigrationBanner,
     Widget,
     AccessToken,
+    Icon,
   },
   mixins: [inboxMixin],
   setup() {
@@ -281,12 +286,8 @@ export default {
       return this.$store.getters['inboxes/getInbox'](this.currentInboxId);
     },
     inboxIcon() {
-      const {
-        medium,
-        channel_type: type,
-        voice_enabled: voiceEnabled,
-      } = this.inbox;
-      return getInboxIconByType(type, medium, 'line', voiceEnabled);
+      const { medium, channel_type: type } = this.inbox;
+      return getInboxIconByType(type, medium, 'line');
     },
     bannerMaxWidth() {
       const narrowTabs = ['collaborators', 'bot-configuration'];
@@ -347,6 +348,12 @@ export default {
     instagramUnauthorized() {
       return this.isAnInstagramChannel && this.inbox.reauthorization_required;
     },
+    showInstagramRestrictionSettingsBanner() {
+      return this.isOnChatwootCloud && this.isAnInstagramChannel;
+    },
+    metaRestrictionStatusUrl() {
+      return META_RESTRICTION_STATUS_URL;
+    },
     tiktokUnauthorized() {
       return this.isATiktokChannel && this.inbox.reauthorization_required;
     },
@@ -383,11 +390,6 @@ export default {
       return (
         this.isAWhatsAppCloudChannel &&
         this.isEmbeddedSignupWhatsApp &&
-        (!this.isOnChatwootCloud ||
-          this.isFeatureEnabledonAccount(
-            this.accountId,
-            FEATURE_FLAGS.WHATSAPP_EMBEDDED_SIGNUP_FLOW
-          )) &&
         this.inbox.reauthorization_required
       );
     },
@@ -813,6 +815,29 @@ export default {
           :class="bannerMaxWidth"
           @start="openWhatsAppManualMigrationDialog"
         />
+        <Banner
+          v-if="showInstagramRestrictionSettingsBanner"
+          color="amber"
+          class="mx-6 mb-4 max-w-4xl"
+        >
+          <div class="flex items-start gap-3 text-start">
+            <Icon
+              icon="i-lucide-triangle-alert"
+              class="flex-shrink-0 size-4 mt-0.5"
+            />
+            <span>
+              {{ $t('INBOX_MGMT.ADD.INSTAGRAM.SETTINGS_RESTRICTED_WARNING') }}
+              <a
+                :href="metaRestrictionStatusUrl"
+                class="link underline"
+                rel="noopener noreferrer nofollow"
+                target="_blank"
+              >
+                {{ $t('INBOX_MGMT.ADD.INSTAGRAM.STATUS_LINK') }}
+              </a>
+            </span>
+          </div>
+        </Banner>
 
         <div
           v-if="selectedTabKey === 'inbox-settings'"

app/javascript/dashboard/routes/dashboard/settings/inbox/channels/Whatsapp.vue

@@ -42,7 +42,9 @@ const shouldShowWhatsappEmbeddedSignup = computed(() => {
     selectedProvider.value === PROVIDER_TYPES.WHATSAPP &&
     hasWhatsappAppId.value &&
     (!isOnChatwootCloud.value ||
-      isCloudFeatureEnabled(FEATURE_FLAGS.WHATSAPP_EMBEDDED_SIGNUP_FLOW))
+      isCloudFeatureEnabled(
+        FEATURE_FLAGS.WHATSAPP_EMBEDDED_SIGNUP_INBOX_CREATION
+      ))
   );
 });
 

app/javascript/dashboard/routes/dashboard/settings/inbox/settingsPage/ConfigurationPage.vue

@@ -56,7 +56,6 @@ export default {
     ...mapGetters({
       accountId: 'getCurrentAccountId',
       isFeatureEnabledonAccount: 'accounts/isFeatureEnabledonAccount',
-      isOnChatwootCloud: 'globalConfig/isOnChatwootCloud',
     }),
     isEmbeddedSignupWhatsApp() {
       return this.inbox.provider_config?.source === 'embedded_signup';
@@ -66,9 +65,7 @@ export default {
         this.isEmbeddedSignupWhatsApp &&
         this.isFeatureEnabledonAccount(
           this.accountId,
-          this.isOnChatwootCloud
-            ? FEATURE_FLAGS.WHATSAPP_EMBEDDED_SIGNUP_FLOW
-            : FEATURE_FLAGS.WHATSAPP_RECONFIGURE
+          FEATURE_FLAGS.WHATSAPP_RECONFIGURE
         )
       );
     },

app/javascript/dashboard/store/captain/agentSessions.js

@@ -1,62 +0,0 @@
-import CaptainAgentSessionsAPI from 'dashboard/api/captain/agentSessions';
-import camelcaseKeys from 'camelcase-keys';
-
-const SET_SESSION = 'SET_SESSION';
-const SET_FETCHING = 'SET_FETCHING';
-
-// Session capture runs right after the message is broadcast (and well after,
-// for handoff notes created mid-run), so a 404 on a fresh message may just
-// mean the session isn't written yet. Skip caching those so a later
-// hover/click retries; older misses are permanent (V1 messages, failed runs).
-const RECENT_MESSAGE_WINDOW_SECONDS = 60;
-
-// Caches Captain agent-session metadata per message id. A missing session
-// (404) is cached as null so the UI shows an empty state without refetching.
-export default {
-  namespaced: true,
-  state: {
-    sessions: {},
-    fetchingIds: [],
-  },
-  getters: {
-    getSessionByMessageId: state => messageId => state.sessions[messageId],
-    isFetching: state => messageId => state.fetchingIds.includes(messageId),
-    hasFetched: state => messageId => messageId in state.sessions,
-  },
-  actions: {
-    fetch: async ({ state, commit }, { messageId, createdAt }) => {
-      if (messageId in state.sessions) return;
-      if (state.fetchingIds.includes(messageId)) return;
-
-      commit(SET_FETCHING, { messageId, isFetching: true });
-      try {
-        const { data } = await CaptainAgentSessionsAPI.show(messageId);
-        commit(SET_SESSION, {
-          messageId,
-          session: camelcaseKeys(data, { deep: true }),
-        });
-      } catch (error) {
-        const isRecentMessage =
-          createdAt &&
-          Date.now() / 1000 - createdAt < RECENT_MESSAGE_WINDOW_SECONDS;
-        // Only a 404 means "no session exists"; transient failures (5xx,
-        // network errors) stay uncached so a later hover retries.
-        if (error.response?.status === 404 && !isRecentMessage) {
-          commit(SET_SESSION, { messageId, session: null });
-        }
-      } finally {
-        commit(SET_FETCHING, { messageId, isFetching: false });
-      }
-    },
-  },
-  mutations: {
-    [SET_SESSION](state, { messageId, session }) {
-      state.sessions = { ...state.sessions, [messageId]: session };
-    },
-    [SET_FETCHING](state, { messageId, isFetching }) {
-      state.fetchingIds = isFetching
-        ? [...state.fetchingIds, messageId]
-        : state.fetchingIds.filter(id => id !== messageId);
-    },
-  },
-};

app/javascript/dashboard/store/index.js

@@ -50,7 +50,6 @@ import teamMembers from './modules/teamMembers';
 import teams from './modules/teams';
 import userNotificationSettings from './modules/userNotificationSettings';
 import webhooks from './modules/webhooks';
-import captainAgentSessions from './captain/agentSessions';
 import captainAssistants from './captain/assistant';
 import captainDocuments from './captain/document';
 import captainResponses from './captain/response';
@@ -116,7 +115,6 @@ export default createStore({
     teams,
     userNotificationSettings,
     webhooks,
-    captainAgentSessions,
     captainAssistants,
     captainDocuments,
     captainResponses,

app/javascript/shared/components/ui/MultiselectDropdown.vue

@@ -68,10 +68,6 @@ const isAgentBot = computed(
   () => props.selectedItem?.assignee_type === 'AgentBot'
 );
 
-const selectedItemName = computed(() =>
-  !props.selectedItem?.name && isAgentBot.value ? '-' : props.selectedItem?.name
-);
-
 const selectedThumbnail = computed(
   () => props.selectedItem?.thumbnail || props.selectedItem?.avatar_url
 );
@@ -99,16 +95,16 @@ const selectedThumbnail = computed(
           <h4
             v-else
             class="items-center overflow-hidden text-sm leading-tight whitespace-nowrap text-ellipsis text-n-slate-12"
-            :title="selectedItemName"
+            :title="selectedItem.name"
           >
-            {{ selectedItemName }}
+            {{ selectedItem.name }}
           </h4>
         </div>
         <Avatar
           v-if="hasValue && hasThumbnail && (isAgentBot || !hasIcon)"
           :src="selectedThumbnail"
           :status="selectedItem.availability_status"
-          :name="selectedItemName"
+          :name="selectedItem.name"
           :icon-name="isAgentBot ? 'i-lucide-bot' : undefined"
           :size="24"
           hide-offline-status

app/javascript/shared/components/ui/MultiselectDropdownItems.vue

@@ -53,9 +53,7 @@ export default {
   computed: {
     filteredOptions() {
       return this.options.filter(option => {
-        return (option.name || '')
-          .toLowerCase()
-          .includes(this.search.toLowerCase());
+        return option.name.toLowerCase().includes(this.search.toLowerCase());
       });
     },
     noResult() {

app/javascript/widget/components/ChatFooter.vue

@@ -11,8 +11,6 @@ import { IFrameHelper } from '../helpers/utils';
 import { CHATWOOT_ON_START_CONVERSATION } from '../constants/sdkEvents';
 import { emitter } from 'shared/helpers/mitt';
 
-const TRANSCRIPT_COOLDOWN_MS = 15000;
-
 export default {
   components: {
     ChatInputWrap,
@@ -26,9 +24,6 @@ export default {
   data() {
     return {
       inReplyTo: null,
-      isSendingTranscript: false,
-      transcriptCooldown: false,
-      transcriptCooldownTimer: null,
     };
   },
   computed: {
@@ -62,9 +57,6 @@ export default {
   mounted() {
     emitter.on(BUS_EVENTS.TOGGLE_REPLY_TO_MESSAGE, this.toggleReplyTo);
   },
-  beforeUnmount() {
-    clearTimeout(this.transcriptCooldownTimer);
-  },
   methods: {
     ...mapActions('conversation', ['sendMessage', 'sendAttachment']),
     ...mapActions('conversationAttributes', ['getAttributes']),
@@ -98,35 +90,19 @@ export default {
     toggleReplyTo(message) {
       this.inReplyTo = message;
     },
-    startTranscriptCooldown() {
-      this.transcriptCooldown = true;
-      clearTimeout(this.transcriptCooldownTimer);
-      this.transcriptCooldownTimer = setTimeout(() => {
-        this.transcriptCooldown = false;
-      }, TRANSCRIPT_COOLDOWN_MS);
-    },
     async sendTranscript() {
-      if (
-        !this.hasEmail ||
-        this.isSendingTranscript ||
-        this.transcriptCooldown
-      ) {
-        return;
-      }
-      this.isSendingTranscript = true;
-      try {
-        await sendEmailTranscript();
-        this.startTranscriptCooldown();
-        emitter.emit(BUS_EVENTS.SHOW_ALERT, {
-          message: this.$t('EMAIL_TRANSCRIPT.SEND_EMAIL_SUCCESS'),
-          type: 'success',
-        });
-      } catch (error) {
-        emitter.emit(BUS_EVENTS.SHOW_ALERT, {
-          message: this.$t('EMAIL_TRANSCRIPT.SEND_EMAIL_ERROR'),
-        });
-      } finally {
-        this.isSendingTranscript = false;
+      if (this.hasEmail) {
+        try {
+          await sendEmailTranscript();
+          emitter.emit(BUS_EVENTS.SHOW_ALERT, {
+            message: this.$t('EMAIL_TRANSCRIPT.SEND_EMAIL_SUCCESS'),
+            type: 'success',
+          });
+        } catch (error) {
+          emitter.$emit(BUS_EVENTS.SHOW_ALERT, {
+            message: this.$t('EMAIL_TRANSCRIPT.SEND_EMAIL_ERROR'),
+          });
+        }
       }
     },
   },
@@ -168,7 +144,6 @@ export default {
       v-if="showEmailTranscriptButton"
       type="clear"
       class="font-normal"
-      :disabled="isSendingTranscript || transcriptCooldown"
       @click="sendTranscript"
     >
       {{ $t('EMAIL_TRANSCRIPT.BUTTON_TEXT') }}