diff --git a/Gemfile b/Gemfile
index 46b11ef1d..1ae6cf093 100644
--- a/Gemfile
+++ b/Gemfile
@@ -215,7 +215,7 @@ group :production do
 end
 
 group :development do
-  gem 'annotate'
+  gem 'annotaterb'
   gem 'bullet'
   gem 'letter_opener'
   gem 'scss_lint', require: false
diff --git a/Gemfile.lock b/Gemfile.lock
index 55cfdef7e..15ed841ac 100644
--- a/Gemfile.lock
+++ b/Gemfile.lock
@@ -128,9 +128,9 @@ GEM
       selectize-rails (~> 0.6)
     ai-agents (0.7.0)
       ruby_llm (~> 1.8.2)
-    annotate (3.2.0)
-      activerecord (>= 3.2, < 8.0)
-      rake (>= 10.4, < 14.0)
+    annotaterb (4.20.0)
+      activerecord (>= 6.0.0)
+      activesupport (>= 6.0.0)
     ast (2.4.3)
     attr_extras (7.1.0)
     audited (5.4.1)
@@ -827,6 +827,7 @@ GEM
       faraday-net_http (>= 1)
       faraday-retry (>= 1)
       marcel (~> 1.0)
+      ruby_llm-schema (~> 0.2.1)
       zeitwerk (~> 2)
     ruby_llm-schema (0.2.5)
     ruby_parser (3.20.0)
@@ -1018,7 +1019,7 @@ DEPENDENCIES
   administrate-field-active_storage (>= 1.0.3)
   administrate-field-belongs_to_search (>= 0.9.0)
   ai-agents (>= 0.7.0)
-  annotate
+  annotaterb
   attr_extras
   audited (~> 5.4, >= 5.4.1)
   aws-actionmailbox-ses (~> 0)
diff --git a/app/controllers/api/v1/accounts/inbox_csat_templates_controller.rb b/app/controllers/api/v1/accounts/inbox_csat_templates_controller.rb
new file mode 100644
index 000000000..d17fe35fb
--- /dev/null
+++ b/app/controllers/api/v1/accounts/inbox_csat_templates_controller.rb
@@ -0,0 +1,160 @@
+class Api::V1::Accounts::InboxCsatTemplatesController < Api::V1::Accounts::BaseController
+  DEFAULT_BUTTON_TEXT = 'Please rate us'.freeze
+  DEFAULT_LANGUAGE = 'en'.freeze
+
+  before_action :fetch_inbox
+  before_action :validate_whatsapp_channel
+
+  def show
+    template = @inbox.csat_config&.dig('template')
+    return render json: { template_exists: false } unless template
+
+    template_name = template['name'] || Whatsapp::CsatTemplateNameService.csat_template_name(@inbox.id)
+    status_result = @inbox.channel.provider_service.get_template_status(template_name)
+
+    render_template_status_response(status_result, template_name)
+  rescue StandardError => e
+    Rails.logger.error "Error fetching CSAT template status: #{e.message}"
+    render json: { error: e.message }, status: :internal_server_error
+  end
+
+  def create
+    template_params = extract_template_params
+    return render_missing_message_error if template_params[:message].blank?
+
+    # Delete existing template even though we are using a new one.
+    # We don't want too many templates in the business portfolio, but the create operation shouldn't fail if deletion fails.
+    delete_existing_template_if_needed
+
+    result = create_template_via_provider(template_params)
+    render_template_creation_result(result)
+  rescue ActionController::ParameterMissing
+    render json: { error: 'Template parameters are required' }, status: :unprocessable_entity
+  rescue StandardError => e
+    Rails.logger.error "Error creating CSAT template: #{e.message}"
+    render json: { error: 'Template creation failed' }, status: :internal_server_error
+  end
+
+  private
+
+  def fetch_inbox
+    @inbox = Current.account.inboxes.find(params[:inbox_id])
+    authorize @inbox, :show?
+  end
+
+  def validate_whatsapp_channel
+    return if @inbox.whatsapp?
+
+    render json: { error: 'CSAT template operations only available for WhatsApp channels' },
+           status: :bad_request
+  end
+
+  def extract_template_params
+    params.require(:template).permit(:message, :button_text, :language)
+  end
+
+  def render_missing_message_error
+    render json: { error: 'Message is required' }, status: :unprocessable_entity
+  end
+
+  def create_template_via_provider(template_params)
+    template_config = {
+      message: template_params[:message],
+      button_text: template_params[:button_text] || DEFAULT_BUTTON_TEXT,
+      base_url: ENV.fetch('FRONTEND_URL', 'http://localhost:3000'),
+      language: template_params[:language] || DEFAULT_LANGUAGE,
+      template_name: Whatsapp::CsatTemplateNameService.csat_template_name(@inbox.id)
+    }
+
+    @inbox.channel.provider_service.create_csat_template(template_config)
+  end
+
+  def render_template_creation_result(result)
+    if result[:success]
+      render_successful_template_creation(result)
+    else
+      render_failed_template_creation(result)
+    end
+  end
+
+  def render_successful_template_creation(result)
+    render json: {
+      template: {
+        name: result[:template_name],
+        template_id: result[:template_id],
+        status: 'PENDING',
+        language: result[:language] || DEFAULT_LANGUAGE
+      }
+    }, status: :created
+  end
+
+  def render_failed_template_creation(result)
+    whatsapp_error = parse_whatsapp_error(result[:response_body])
+    error_message = whatsapp_error[:user_message] || result[:error]
+
+    render json: {
+      error: error_message,
+      details: whatsapp_error[:technical_details]
+    }, status: :unprocessable_entity
+  end
+
+  def delete_existing_template_if_needed
+    template = @inbox.csat_config&.dig('template')
+    return true if template.blank?
+
+    template_name = template['name']
+    return true if template_name.blank?
+
+    template_status = @inbox.channel.provider_service.get_template_status(template_name)
+    return true unless template_status[:success]
+
+    deletion_result = @inbox.channel.provider_service.delete_csat_template(template_name)
+    if deletion_result[:success]
+      Rails.logger.info "Deleted existing CSAT template '#{template_name}' for inbox #{@inbox.id}"
+      true
+    else
+      Rails.logger.warn "Failed to delete existing CSAT template '#{template_name}' for inbox #{@inbox.id}: #{deletion_result[:response_body]}"
+      false
+    end
+  rescue StandardError => e
+    Rails.logger.error "Error during template deletion for inbox #{@inbox.id}: #{e.message}"
+    false
+  end
+
+  def render_template_status_response(status_result, template_name)
+    if status_result[:success]
+      render json: {
+        template_exists: true,
+        template_name: template_name,
+        status: status_result[:template][:status],
+        template_id: status_result[:template][:id]
+      }
+    else
+      render json: {
+        template_exists: false,
+        error: 'Template not found'
+      }
+    end
+  end
+
+  def parse_whatsapp_error(response_body)
+    return { user_message: nil, technical_details: nil } if response_body.blank?
+
+    begin
+      error_data = JSON.parse(response_body)
+      whatsapp_error = error_data['error'] || {}
+
+      user_message = whatsapp_error['error_user_msg'] || whatsapp_error['message']
+      technical_details = {
+        code: whatsapp_error['code'],
+        subcode: whatsapp_error['error_subcode'],
+        type: whatsapp_error['type'],
+        title: whatsapp_error['error_user_title']
+      }.compact
+
+      { user_message: user_message, technical_details: technical_details }
+    rescue JSON::ParserError
+      { user_message: nil, technical_details: response_body }
+    end
+  end
+end
diff --git a/app/controllers/api/v1/accounts/inboxes_controller.rb b/app/controllers/api/v1/accounts/inboxes_controller.rb
index ae1d4369a..1c8845c04 100644
--- a/app/controllers/api/v1/accounts/inboxes_controller.rb
+++ b/app/controllers/api/v1/accounts/inboxes_controller.rb
@@ -152,31 +152,37 @@ class Api::V1::Accounts::InboxesController < Api::V1::Accounts::BaseController
   end
 
   def format_csat_config(config)
-    {
-      display_type: config['display_type'] || 'emoji',
-      message: config['message'] || '',
-      survey_rules: {
-        operator: config.dig('survey_rules', 'operator') || 'contains',
-        values: config.dig('survey_rules', 'values') || []
-      }
+    formatted = {
+      'display_type' => config['display_type'] || 'emoji',
+      'message' => config['message'] || '',
+      :survey_rules => {
+        'operator' => config.dig('survey_rules', 'operator') || 'contains',
+        'values' => config.dig('survey_rules', 'values') || []
+      },
+      'button_text' => config['button_text'] || 'Please rate us',
+      'language' => config['language'] || 'en'
     }
+    format_template_config(config, formatted)
+    formatted
+  end
+
+  def format_template_config(config, formatted)
+    formatted['template'] = config['template'] if config['template'].present?
   end
 
   def inbox_attributes
     [:name, :avatar, :greeting_enabled, :greeting_message, :enable_email_collect, :csat_survey_enabled,
      :enable_auto_assignment, :working_hours_enabled, :out_of_office_message, :timezone, :allow_messages_after_resolved,
      :lock_to_single_conversation, :portal_id, :sender_name_type, :business_name,
-     { csat_config: [:display_type, :message, { survey_rules: [:operator, { values: [] }] }] }]
+     { csat_config: [:display_type, :message, :button_text, :language,
+                     { survey_rules: [:operator, { values: [] }],
+                       template: [:name, :template_id, :created_at, :language] }] }]
   end
 
   def permitted_params(channel_attributes = [])
     # We will remove this line after fixing https://linear.app/chatwoot/issue/CW-1567/null-value-passed-as-null-string-to-backend
     params.each { |k, v| params[k] = params[k] == 'null' ? nil : v }
-
-    params.permit(
-      *inbox_attributes,
-      channel: [:type, *channel_attributes]
-    )
+    params.permit(*inbox_attributes, channel: [:type, *channel_attributes])
   end
 
   def channel_type_from_params
@@ -192,11 +198,7 @@ class Api::V1::Accounts::InboxesController < Api::V1::Accounts::BaseController
   end
 
   def get_channel_attributes(channel_type)
-    if channel_type.constantize.const_defined?(:EDITABLE_ATTRS)
-      channel_type.constantize::EDITABLE_ATTRS.presence
-    else
-      []
-    end
+    channel_type.constantize.const_defined?(:EDITABLE_ATTRS) ? channel_type.constantize::EDITABLE_ATTRS.presence : []
   end
 
   def whatsapp_channel?
diff --git a/app/javascript/dashboard/components-next/Editor/Editor.vue b/app/javascript/dashboard/components-next/Editor/Editor.vue
index 67936fa59..90b7a0c31 100644
--- a/app/javascript/dashboard/components-next/Editor/Editor.vue
+++ b/app/javascript/dashboard/components-next/Editor/Editor.vue
@@ -19,12 +19,12 @@ const props = defineProps({
   },
   enableVariables: { type: Boolean, default: false },
   enableCannedResponses: { type: Boolean, default: true },
-  enabledMenuOptions: { type: Array, default: () => [] },
   enableCaptainTools: { type: Boolean, default: false },
   signature: { type: String, default: '' },
   allowSignature: { type: Boolean, default: false },
   sendWithSignature: { type: Boolean, default: false },
   channelType: { type: String, default: '' },
+  medium: { type: String, default: '' },
 });
 
 const emit = defineEmits(['update:modelValue']);
@@ -102,12 +102,12 @@ watch(
         :disabled="disabled"
         :enable-variables="enableVariables"
         :enable-canned-responses="enableCannedResponses"
-        :enabled-menu-options="enabledMenuOptions"
         :enable-captain-tools="enableCaptainTools"
         :signature="signature"
         :allow-signature="allowSignature"
         :send-with-signature="sendWithSignature"
         :channel-type="channelType"
+        :medium="medium"
         @input="handleInput"
         @focus="handleFocus"
         @blur="handleBlur"
@@ -139,19 +139,6 @@ watch(
 .editor-wrapper {
   ::v-deep {
     .ProseMirror-menubar-wrapper {
-      @apply gap-2 !important;
-
-      .ProseMirror-menubar {
-        @apply bg-transparent dark:bg-transparent w-fit left-1 pt-0 h-5 !top-0 !relative !important;
-
-        .ProseMirror-menuitem {
-          @apply h-5 !important;
-        }
-
-        .ProseMirror-icon {
-          @apply p-1 w-3 h-3 text-n-slate-12 dark:text-n-slate-12 !important;
-        }
-      }
       .ProseMirror.ProseMirror-woot-style {
         p {
           @apply first:mt-0 !important;
diff --git a/app/javascript/dashboard/components-next/HelpCenter/Pages/ArticleEditorPage/ArticleEditor.vue b/app/javascript/dashboard/components-next/HelpCenter/Pages/ArticleEditorPage/ArticleEditor.vue
index 7beff200e..4c4d95f0c 100644
--- a/app/javascript/dashboard/components-next/HelpCenter/Pages/ArticleEditorPage/ArticleEditor.vue
+++ b/app/javascript/dashboard/components-next/HelpCenter/Pages/ArticleEditorPage/ArticleEditor.vue
@@ -172,7 +172,7 @@ const previewArticle = () => {
         @apply mr-0;
 
         .ProseMirror-icon {
-          @apply p-0 mt-1 !mr-0;
+          @apply p-0 mt-0 !mr-0;
 
           svg {
             width: 20px !important;
diff --git a/app/javascript/dashboard/components-next/NewConversation/components/ActionButtons.vue b/app/javascript/dashboard/components-next/NewConversation/components/ActionButtons.vue
index 92c5850de..cb1f9d99d 100644
--- a/app/javascript/dashboard/components-next/NewConversation/components/ActionButtons.vue
+++ b/app/javascript/dashboard/components-next/NewConversation/components/ActionButtons.vue
@@ -7,7 +7,7 @@ import { vOnClickOutside } from '@vueuse/components';
 import { ALLOWED_FILE_TYPES } from 'shared/constants/messages';
 import { useKeyboardEvents } from 'dashboard/composables/useKeyboardEvents';
 import FileUpload from 'vue-upload-component';
-import { extractTextFromMarkdown } from 'dashboard/helper/editorHelper';
+import { INBOX_TYPES } from 'dashboard/helper/inbox';
 
 import Button from 'dashboard/components-next/button/Button.vue';
 import WhatsAppOptions from './WhatsAppOptions.vue';
@@ -50,12 +50,6 @@ const EmojiInput = defineAsyncComponent(
   () => import('shared/components/emoji/EmojiInput.vue')
 );
 
-const signatureToApply = computed(() =>
-  props.isEmailOrWebWidgetInbox
-    ? props.messageSignature
-    : extractTextFromMarkdown(props.messageSignature)
-);
-
 const {
   fetchSignatureFlagFromUISettings,
   setSignatureFlagForInbox,
@@ -80,12 +74,20 @@ const isRegularMessageMode = computed(() => {
   return !props.isWhatsappInbox && !props.isTwilioWhatsAppInbox;
 });
 
+const isVoiceInbox = computed(() => props.channelType === INBOX_TYPES.VOICE);
+
+const shouldShowSignatureButton = computed(() => {
+  return (
+    props.hasSelectedInbox && isRegularMessageMode.value && !isVoiceInbox.value
+  );
+});
+
 const setSignature = () => {
-  if (signatureToApply.value) {
+  if (props.messageSignature) {
     if (sendWithSignature.value) {
-      emit('addSignature', signatureToApply.value);
+      emit('addSignature', props.messageSignature);
     } else {
-      emit('removeSignature', signatureToApply.value);
+      emit('removeSignature', props.messageSignature);
     }
   }
 };
@@ -101,7 +103,7 @@ watch(
   () => props.hasSelectedInbox,
   newValue => {
     nextTick(() => {
-      if (newValue && props.isEmailOrWebWidgetInbox) setSignature();
+      if (newValue && !isVoiceInbox.value) setSignature();
     });
   },
   { immediate: true }
@@ -220,7 +222,7 @@ useKeyboardEvents(keyboardEvents);
         />
       </FileUpload>
       <Button
-        v-if="hasSelectedInbox && isRegularMessageMode"
+        v-if="shouldShowSignatureButton"
         icon="i-lucide-signature"
         color="slate"
         size="sm"
diff --git a/app/javascript/dashboard/components-next/NewConversation/components/AttachmentPreviews.vue b/app/javascript/dashboard/components-next/NewConversation/components/AttachmentPreviews.vue
index a546fe0df..4f799fcbd 100644
--- a/app/javascript/dashboard/components-next/NewConversation/components/AttachmentPreviews.vue
+++ b/app/javascript/dashboard/components-next/NewConversation/components/AttachmentPreviews.vue
@@ -39,7 +39,7 @@ const removeAttachment = id => {
 </script>
 
 <template>
-  <div class="flex flex-col gap-4 p-4">
+  <div class="flex flex-col gap-4 p-4 max-h-48 overflow-y-auto">
     <div
       v-if="filteredImageAttachments.length > 0"
       class="flex flex-wrap gap-3"
diff --git a/app/javascript/dashboard/components-next/NewConversation/components/ComposeNewConversationForm.vue b/app/javascript/dashboard/components-next/NewConversation/components/ComposeNewConversationForm.vue
index a02d6d495..74836219b 100644
--- a/app/javascript/dashboard/components-next/NewConversation/components/ComposeNewConversationForm.vue
+++ b/app/javascript/dashboard/components-next/NewConversation/components/ComposeNewConversationForm.vue
@@ -6,7 +6,7 @@ import { INBOX_TYPES } from 'dashboard/helper/inbox';
 import {
   appendSignature,
   removeSignature,
-  extractTextFromMarkdown,
+  getEffectiveChannelType,
 } from 'dashboard/helper/editorHelper';
 import {
   buildContactableInboxesList,
@@ -87,6 +87,12 @@ const whatsappMessageTemplates = computed(() =>
 
 const inboxChannelType = computed(() => props.targetInbox?.channelType || '');
 
+const inboxMedium = computed(() => props.targetInbox?.medium || '');
+
+const effectiveChannelType = computed(() =>
+  getEffectiveChannelType(inboxChannelType.value, inboxMedium.value)
+);
+
 const validationRules = computed(() => ({
   selectedContact: { required },
   targetInbox: { required },
@@ -194,6 +200,7 @@ const setSelectedContact = async ({ value, action, ...rest }) => {
 
 const handleInboxAction = ({ value, action, ...rest }) => {
   v$.value.$reset();
+  state.message = '';
   emit('updateTargetInbox', { ...rest });
   showInboxesDropdown.value = false;
   state.attachedFiles = [];
@@ -202,25 +209,28 @@ const handleInboxAction = ({ value, action, ...rest }) => {
 const removeSignatureFromMessage = () => {
   // Always remove the signature from message content when inbox/contact is removed
   // to ensure no leftover signature content remains
-  const signatureToRemove = inboxTypes.value.isEmailOrWebWidget
-    ? props.messageSignature
-    : extractTextFromMarkdown(props.messageSignature);
-  if (signatureToRemove) {
-    state.message = removeSignature(state.message, signatureToRemove);
+  if (props.messageSignature) {
+    state.message = removeSignature(
+      state.message,
+      props.messageSignature,
+      effectiveChannelType.value
+    );
   }
 };
 
 const removeTargetInbox = value => {
   v$.value.$reset();
   removeSignatureFromMessage();
+  state.message = '';
   emit('updateTargetInbox', value);
   state.attachedFiles = [];
 };
 
 const clearSelectedContact = () => {
-  emit('clearSelectedContact');
-  state.attachedFiles = [];
   removeSignatureFromMessage();
+  emit('clearSelectedContact');
+  state.message = '';
+  state.attachedFiles = [];
 };
 
 const onClickInsertEmoji = emoji => {
@@ -228,11 +238,19 @@ const onClickInsertEmoji = emoji => {
 };
 
 const handleAddSignature = signature => {
-  state.message = appendSignature(state.message, signature);
+  state.message = appendSignature(
+    state.message,
+    signature,
+    effectiveChannelType.value
+  );
 };
 
 const handleRemoveSignature = signature => {
-  state.message = removeSignature(state.message, signature);
+  state.message = removeSignature(
+    state.message,
+    signature,
+    effectiveChannelType.value
+  );
 };
 
 const handleAttachFile = files => {
@@ -356,10 +374,10 @@ const shouldShowMessageEditor = computed(() => {
       v-model="state.message"
       :message-signature="messageSignature"
       :send-with-signature="sendWithSignature"
-      :is-email-or-web-widget-inbox="inboxTypes.isEmailOrWebWidget"
       :has-errors="validationStates.isMessageInvalid"
       :has-attachments="state.attachedFiles.length > 0"
       :channel-type="inboxChannelType"
+      :medium="targetInbox?.medium || ''"
     />
 
     <AttachmentPreviews
diff --git a/app/javascript/dashboard/components-next/NewConversation/components/MessageEditor.vue b/app/javascript/dashboard/components-next/NewConversation/components/MessageEditor.vue
index aa5a85f48..ef523a288 100644
--- a/app/javascript/dashboard/components-next/NewConversation/components/MessageEditor.vue
+++ b/app/javascript/dashboard/components-next/NewConversation/components/MessageEditor.vue
@@ -1,127 +1,49 @@
 <script setup>
-import { ref, watch, computed, nextTick } from 'vue';
+import { computed } from 'vue';
 import { useI18n } from 'vue-i18n';
-import {
-  appendSignature,
-  extractTextFromMarkdown,
-  removeSignature,
-} from 'dashboard/helper/editorHelper';
 
 import Editor from 'dashboard/components-next/Editor/Editor.vue';
-import TextArea from 'dashboard/components-next/textarea/TextArea.vue';
-import CannedResponse from 'dashboard/components/widgets/conversation/CannedResponse.vue';
 
 const props = defineProps({
-  isEmailOrWebWidgetInbox: { type: Boolean, required: true },
   hasErrors: { type: Boolean, default: false },
   hasAttachments: { type: Boolean, default: false },
   sendWithSignature: { type: Boolean, default: false },
   messageSignature: { type: String, default: '' },
   channelType: { type: String, default: '' },
+  medium: { type: String, default: '' },
 });
 
+const editorKey = computed(() => `editor-${props.channelType}-${props.medium}`);
+
 const { t } = useI18n();
 
 const modelValue = defineModel({
   type: String,
   default: '',
 });
-
-const state = ref({
-  hasSlashCommand: false,
-  showMentions: false,
-  mentionSearchKey: '',
-});
-
-const plainTextSignature = computed(() =>
-  extractTextFromMarkdown(props.messageSignature)
-);
-
-watch(
-  modelValue,
-  newValue => {
-    if (props.isEmailOrWebWidgetInbox) return;
-
-    const bodyWithoutSignature = newValue
-      ? removeSignature(newValue, plainTextSignature.value)
-      : '';
-
-    // Check if message starts with slash
-    const startsWithSlash = bodyWithoutSignature.startsWith('/');
-
-    // Update slash command and mentions state
-    state.value = {
-      ...state.value,
-      hasSlashCommand: startsWithSlash,
-      showMentions: startsWithSlash,
-      mentionSearchKey: startsWithSlash ? bodyWithoutSignature.slice(1) : '',
-    };
-  },
-  { immediate: true }
-);
-
-const hideMention = () => {
-  state.value.showMentions = false;
-};
-
-const replaceText = async message => {
-  // Only append signature on replace if sendWithSignature is true
-  const finalMessage = props.sendWithSignature
-    ? appendSignature(message, plainTextSignature.value)
-    : message;
-
-  await nextTick();
-  modelValue.value = finalMessage;
-};
 </script>
 
 <template>
   <div class="flex-1 h-full" :class="[!hasAttachments && 'min-h-[200px]']">
-    <template v-if="isEmailOrWebWidgetInbox">
-      <Editor
-        v-model="modelValue"
-        :placeholder="
-          t('COMPOSE_NEW_CONVERSATION.FORM.MESSAGE_EDITOR.PLACEHOLDER')
-        "
-        class="[&>div]:!border-transparent [&>div]:px-4 [&>div]:py-4 [&>div]:!bg-transparent h-full [&_.ProseMirror-woot-style]:!max-h-[200px]"
-        :class="
-          hasErrors
-            ? '[&_.empty-node]:before:!text-n-ruby-9 [&_.empty-node]:dark:before:!text-n-ruby-9'
-            : ''
-        "
-        enable-variables
-        :show-character-count="false"
-        :signature="messageSignature"
-        allow-signature
-        :send-with-signature="sendWithSignature"
-        :channel-type="channelType"
-      />
-    </template>
-    <template v-else>
-      <TextArea
-        v-model="modelValue"
-        :placeholder="
-          t('COMPOSE_NEW_CONVERSATION.FORM.MESSAGE_EDITOR.PLACEHOLDER')
-        "
-        class="!px-0 [&>div]:!px-4 [&>div]:!border-transparent [&>div]:!bg-transparent"
-        :custom-text-area-class="
-          hasErrors
-            ? 'placeholder:!text-n-ruby-9 dark:placeholder:!text-n-ruby-9'
-            : ''
-        "
-        auto-height
-        allow-signature
-        :signature="messageSignature"
-        :send-with-signature="sendWithSignature"
-      >
-        <CannedResponse
-          v-if="state.showMentions && state.hasSlashCommand"
-          v-on-clickaway="hideMention"
-          class="normal-editor__canned-box"
-          :search-key="state.mentionSearchKey"
-          @replace="replaceText"
-        />
-      </TextArea>
-    </template>
+    <Editor
+      :key="editorKey"
+      v-model="modelValue"
+      :placeholder="
+        t('COMPOSE_NEW_CONVERSATION.FORM.MESSAGE_EDITOR.PLACEHOLDER')
+      "
+      class="[&>div]:!border-transparent [&>div]:px-4 [&>div]:py-4 [&>div]:!bg-transparent h-full [&_.ProseMirror-woot-style]:!max-h-[200px]"
+      :class="
+        hasErrors
+          ? '[&_.empty-node]:before:!text-n-ruby-9 [&_.empty-node]:dark:before:!text-n-ruby-9'
+          : ''
+      "
+      enable-variables
+      :show-character-count="false"
+      :signature="messageSignature"
+      allow-signature
+      :send-with-signature="sendWithSignature"
+      :channel-type="channelType"
+      :medium="medium"
+    />
   </div>
 </template>
diff --git a/app/javascript/dashboard/components/widgets/WootWriter/Editor.vue b/app/javascript/dashboard/components/widgets/WootWriter/Editor.vue
index 8d7a082b4..7a2a489ac 100644
--- a/app/javascript/dashboard/components/widgets/WootWriter/Editor.vue
+++ b/app/javascript/dashboard/components/widgets/WootWriter/Editor.vue
@@ -26,13 +26,11 @@ import { useAlert } from 'dashboard/composables';
 
 import { BUS_EVENTS } from 'shared/constants/busEvents';
 import { CONVERSATION_EVENTS } from 'dashboard/helper/AnalyticsHelper/events';
-import {
-  MESSAGE_EDITOR_MENU_OPTIONS,
-  MESSAGE_EDITOR_IMAGE_RESIZES,
-} from 'dashboard/constants/editor';
+import { MESSAGE_EDITOR_IMAGE_RESIZES } from 'dashboard/constants/editor';
 
 import {
   messageSchema,
+  buildMessageSchema,
   buildEditor,
   EditorView,
   MessageMarkdownTransformer,
@@ -53,6 +51,10 @@ import {
   removeSignature as removeSignatureHelper,
   scrollCursorIntoView,
   setURLWithQueryAndSize,
+  getFormattingForEditor,
+  getSelectionCoords,
+  calculateMenuPosition,
+  getEffectiveChannelType,
 } from 'dashboard/helper/editorHelper';
 import {
   hasPressedEnterAndNotCmdOrShift,
@@ -75,12 +77,12 @@ const props = defineProps({
   enableCannedResponses: { type: Boolean, default: true },
   enableCaptainTools: { type: Boolean, default: false },
   variables: { type: Object, default: () => ({}) },
-  enabledMenuOptions: { type: Array, default: () => [] },
   signature: { type: String, default: '' },
   // allowSignature is a kill switch, ensuring no signature methods
   // are triggered except when this flag is true
   allowSignature: { type: Boolean, default: false },
   channelType: { type: String, default: '' },
+  medium: { type: String, default: '' },
   showImageResizeToolbar: { type: Boolean, default: false }, // A kill switch to show or hide the image toolbar
   focusOnMount: { type: Boolean, default: true },
 });
@@ -103,22 +105,40 @@ const { t } = useI18n();
 
 const TYPING_INDICATOR_IDLE_TIME = 4000;
 const MAXIMUM_FILE_UPLOAD_SIZE = 4; // in MB
+const DEFAULT_FORMATTING = 'Context::Default';
 
-const createState = (
-  content,
-  placeholder,
-  plugins = [],
-  methods = {},
-  enabledMenuOptions = []
-) => {
+const effectiveChannelType = computed(() =>
+  getEffectiveChannelType(props.channelType, props.medium)
+);
+
+const editorSchema = computed(() => {
+  if (!props.channelType) return messageSchema;
+
+  const formatType = props.isPrivate
+    ? DEFAULT_FORMATTING
+    : effectiveChannelType.value;
+  const formatting = getFormattingForEditor(formatType);
+  return buildMessageSchema(formatting.marks, formatting.nodes);
+});
+
+const editorMenuOptions = computed(() => {
+  const formatType = props.isPrivate
+    ? DEFAULT_FORMATTING
+    : effectiveChannelType.value || DEFAULT_FORMATTING;
+  const formatting = getFormattingForEditor(formatType);
+  return formatting.menu;
+});
+
+const createState = (content, placeholder, plugins = [], methods = {}) => {
+  const schema = editorSchema.value;
   return EditorState.create({
-    doc: new MessageMarkdownTransformer(messageSchema).parse(content),
+    doc: new MessageMarkdownTransformer(schema).parse(content),
     plugins: buildEditor({
-      schema: messageSchema,
+      schema,
       placeholder,
       methods,
       plugins,
-      enabledMenuOptions,
+      enabledMenuOptions: editorMenuOptions.value,
     }),
   });
 };
@@ -153,6 +173,8 @@ const range = ref(null);
 const isImageNodeSelected = ref(false);
 const toolbarPosition = ref({ top: 0, left: 0 });
 const selectedImageNode = ref(null);
+const isTextSelected = ref(false); // Tracks text selection and prevents unnecessary re-renders on mouse selection
+const showSelectionMenu = ref(false);
 const sizes = MESSAGE_EDITOR_IMAGE_RESIZES;
 
 // element ref
@@ -174,12 +196,6 @@ const shouldShowCannedResponses = computed(() => {
   );
 });
 
-const editorMenuOptions = computed(() => {
-  return props.enabledMenuOptions.length
-    ? props.enabledMenuOptions
-    : MESSAGE_EDITOR_MENU_OPTIONS;
-});
-
 function createSuggestionPlugin({
   trigger,
   minChars = 0,
@@ -293,8 +309,13 @@ function isBodyEmpty(content) {
 
   // if the signature is present, we need to remove it before checking
   // note that we don't update the editorView, so this is safe
+  // Use effective channel type to match how signature was appended
   const bodyWithoutSignature = props.signature
-    ? removeSignatureHelper(content, props.signature)
+    ? removeSignatureHelper(
+        content,
+        props.signature,
+        effectiveChannelType.value
+      )
     : content;
 
   // trimming should remove all the whitespaces, so we can check the length
@@ -362,7 +383,11 @@ function addSignature() {
   // see if the content is empty, if it is before appending the signature
   // we need to add a paragraph node and move the cursor at the start of the editor
   const contentWasEmpty = isBodyEmpty(content);
-  content = appendSignature(content, props.signature);
+  content = appendSignature(
+    content,
+    props.signature,
+    effectiveChannelType.value
+  );
   // need to reload first, ensuring that the editorView is updated
   reloadState(content);
 
@@ -374,7 +399,11 @@ function addSignature() {
 function removeSignature() {
   if (!props.signature) return;
   let content = props.modelValue;
-  content = removeSignatureHelper(content, props.signature);
+  content = removeSignatureHelper(
+    content,
+    props.signature,
+    effectiveChannelType.value
+  );
   // reload the state, ensuring that the editorView is updated
   reloadState(content);
 }
@@ -400,6 +429,38 @@ function setToolbarPosition() {
   };
 }
 
+function setMenubarPosition({ selection } = {}) {
+  const wrapper = editorRoot.value;
+  if (!selection || !wrapper) return;
+
+  const rect = wrapper.getBoundingClientRect();
+  const isRtl = getComputedStyle(wrapper).direction === 'rtl';
+
+  // Calculate coords and final position
+  const coords = getSelectionCoords(editorView, selection, rect);
+  const { left, top, width } = calculateMenuPosition(coords, rect, isRtl);
+
+  wrapper.style.setProperty('--selection-left', `${left}px`);
+  wrapper.style.setProperty(
+    '--selection-right',
+    `${rect.width - left - width}px`
+  );
+  wrapper.style.setProperty('--selection-top', `${top}px`);
+}
+
+function checkSelection(editorState) {
+  showSelectionMenu.value = false;
+  const hasSelection = editorState.selection.from !== editorState.selection.to;
+  if (hasSelection === isTextSelected.value) return;
+
+  isTextSelected.value = hasSelection;
+  const wrapper = editorRoot.value;
+  if (!wrapper) return;
+
+  wrapper.classList.toggle('has-selection', hasSelection);
+  if (hasSelection) setMenubarPosition(editorState);
+}
+
 function setURLWithQueryAndImageSize(size) {
   if (!props.showImageResizeToolbar) {
     return;
@@ -529,7 +590,9 @@ async function insertNodeIntoEditor(node, from = 0, to = 0) {
 
 function insertContentIntoEditor(content, defaultFrom = 0) {
   const from = defaultFrom || editorView.state.selection.from || 0;
-  let node = new MessageMarkdownTransformer(messageSchema).parse(content);
+  // Use the editor's current schema to ensure compatibility with buildMessageSchema
+  const currentSchema = editorView.state.schema;
+  let node = new MessageMarkdownTransformer(currentSchema).parse(content);
 
   insertNodeIntoEditor(node, from, undefined);
 }
@@ -596,6 +659,7 @@ function createEditorView() {
       if (tx.docChanged) {
         emitOnChange();
       }
+      checkSelection(state);
     },
     handleDOMEvents: {
       keyup: () => {
@@ -761,15 +825,33 @@ useEmitter(BUS_EVENTS.INSERT_INTO_RICH_EDITOR, insertContentIntoEditor);
 @import '@chatwoot/prosemirror-schema/src/styles/base.scss';
 
 .ProseMirror-menubar-wrapper {
-  @apply flex flex-col;
+  @apply flex flex-col gap-3;
 
   .ProseMirror-menubar {
     min-height: 1.25rem !important;
-    @apply -ml-2.5 pb-0 bg-transparent text-n-slate-11;
+    @apply items-center gap-4 flex pb-0 bg-transparent text-n-slate-11 relative ltr:-left-[3px] rtl:-right-[3px];
 
     .ProseMirror-menu-active {
-      @apply bg-n-slate-5 dark:bg-n-solid-3;
+      @apply bg-n-slate-5 dark:bg-n-solid-3 !important;
     }
+
+    .ProseMirror-menuitem {
+      @apply mr-0 size-4 flex items-center justify-center;
+
+      .ProseMirror-icon {
+        @apply size-4 flex items-center justify-center flex-shrink-0;
+
+        svg {
+          @apply size-full;
+        }
+      }
+    }
+  }
+
+  .ProseMirror-menubar:not(:has(*)) {
+    max-height: none !important;
+    min-height: 0 !important;
+    padding: 0 !important;
   }
 
   > .ProseMirror {
@@ -860,4 +942,53 @@ useEmitter(BUS_EVENTS.INSERT_INTO_RICH_EDITOR, insertContentIntoEditor);
 .editor-warning__message {
   @apply text-n-ruby-9 dark:text-n-ruby-9 font-normal text-sm pt-1 pb-0 px-0;
 }
+
+// Float editor menu
+.popover-prosemirror-menu {
+  position: relative;
+
+  .ProseMirror p:last-child {
+    margin-bottom: 10px !important;
+  }
+
+  .ProseMirror-menubar {
+    display: none; // Hide by default
+  }
+
+  &.has-selection {
+    // Hide menu completely when it has no items
+    .ProseMirror-menubar:not(:has(*)) {
+      display: none !important;
+    }
+
+    .ProseMirror-menubar {
+      @apply rounded-lg !px-3 !py-1.5 z-50 bg-n-background items-center gap-4 ml-0 mb-0 shadow-md outline outline-1 outline-n-weak;
+      display: flex;
+      width: fit-content !important;
+      position: absolute !important;
+
+      // Default/LTR: position from left
+      top: var(--selection-top);
+      left: var(--selection-left);
+
+      // RTL: position from right instead
+      [dir='rtl'] & {
+        left: auto;
+        right: var(--selection-right);
+      }
+
+      .ProseMirror-menuitem {
+        @apply mr-0 size-4 flex items-center;
+
+        .ProseMirror-icon {
+          @apply p-0.5 flex-shrink-0;
+        }
+      }
+
+      .ProseMirror-menu-active {
+        @apply bg-n-slate-3;
+      }
+    }
+  }
+}
 </style>
diff --git a/app/javascript/dashboard/components/widgets/WootWriter/ReplyBottomPanel.vue b/app/javascript/dashboard/components/widgets/WootWriter/ReplyBottomPanel.vue
index bc43f4869..80737ac45 100644
--- a/app/javascript/dashboard/components/widgets/WootWriter/ReplyBottomPanel.vue
+++ b/app/javascript/dashboard/components/widgets/WootWriter/ReplyBottomPanel.vue
@@ -78,10 +78,6 @@ export default {
       type: Boolean,
       default: false,
     },
-    showEditorToggle: {
-      type: Boolean,
-      default: false,
-    },
     isOnPrivateNote: {
       type: Boolean,
       default: false,
@@ -130,7 +126,6 @@ export default {
   emits: [
     'replaceText',
     'toggleInsertArticle',
-    'toggleEditor',
     'selectWhatsappTemplate',
     'selectContentTemplate',
     'toggleQuotedReply',
@@ -325,18 +320,8 @@ export default {
         sm
         @click="toggleAudioRecorder"
       />
-      <NextButton
-        v-if="showEditorToggle"
-        v-tooltip.top-end="$t('CONVERSATION.REPLYBOX.TIP_FORMAT_ICON')"
-        icon="i-ph-quotes"
-        slate
-        faded
-        sm
-        @click="$emit('toggleEditor')"
-      />
       <NextButton
         v-if="showAudioPlayStopButton"
-        v-tooltip.top-end="$t('CONVERSATION.REPLYBOX.TIP_FORMAT_ICON')"
         :icon="audioRecorderPlayStopIcon"
         slate
         faded
diff --git a/app/javascript/dashboard/components/widgets/conversation/ReplyBox.vue b/app/javascript/dashboard/components/widgets/conversation/ReplyBox.vue
index 0c08b9bd3..bfff15a4c 100644
--- a/app/javascript/dashboard/components/widgets/conversation/ReplyBox.vue
+++ b/app/javascript/dashboard/components/widgets/conversation/ReplyBox.vue
@@ -45,7 +45,7 @@ import fileUploadMixin from 'dashboard/mixins/fileUploadMixin';
 import {
   appendSignature,
   removeSignature,
-  replaceSignature,
+  getEffectiveChannelType,
   extractTextFromMarkdown,
 } from 'dashboard/helper/editorHelper';
 
@@ -61,7 +61,6 @@ export default {
     ArticleSearchPopover,
     AttachmentPreview,
     AudioRecorder,
-    CannedResponse,
     ReplyBoxBanner,
     EmojiInput,
     MessageSignatureMissingAlert,
@@ -69,11 +68,12 @@ export default {
     ReplyEmailHead,
     ReplyToMessage,
     ReplyTopPanel,
-    ResizableTextArea,
     ContentTemplates,
     WhatsappTemplates,
     WootMessageEditor,
     QuotedEmailPreview,
+    ResizableTextArea,
+    CannedResponse,
   },
   mixins: [inboxMixin, fileUploadMixin, keyboardEventListenerMixins],
   props: {
@@ -86,7 +86,6 @@ export default {
   setup() {
     const {
       uiSettings,
-      updateUISettings,
       isEditorHotKeyEnabled,
       fetchSignatureFlagFromUISettings,
       setQuotedReplyFlagForInbox,
@@ -97,7 +96,6 @@ export default {
 
     return {
       uiSettings,
-      updateUISettings,
       isEditorHotKeyEnabled,
       fetchSignatureFlagFromUISettings,
       setQuotedReplyFlagForInbox,
@@ -115,7 +113,6 @@ export default {
       isRecordingAudio: false,
       recordingAudioState: '',
       recordingAudioDurationText: '',
-      isUploading: false,
       replyType: REPLY_EDITOR_MODES.REPLY,
       mentionSearchKey: '',
       hasSlashCommand: false,
@@ -147,9 +144,12 @@ export default {
       isFeatureEnabledonAccount: 'accounts/isFeatureEnabledonAccount',
     }),
     currentContact() {
-      return this.$store.getters['contacts/getContact'](
-        this.currentChat.meta.sender.id
-      );
+      const senderId = this.currentChat?.meta?.sender?.id;
+      if (!senderId) return {};
+      return this.$store.getters['contacts/getContact'](senderId);
+    },
+    isRichEditorEnabled() {
+      return this.isAWebWidgetInbox || this.isAnEmailChannel || this.isAPIInbox;
     },
     shouldShowReplyToMessage() {
       return (
@@ -159,20 +159,6 @@ export default {
         !this.is360DialogWhatsAppChannel
       );
     },
-    showRichContentEditor() {
-      if (this.isOnPrivateNote || this.isRichEditorEnabled) {
-        return true;
-      }
-
-      if (this.isAPIInbox) {
-        const {
-          display_rich_content_editor: displayRichContentEditor = false,
-        } = this.uiSettings;
-        return displayRichContentEditor;
-      }
-
-      return false;
-    },
     showWhatsappTemplates() {
       // We support templates for API channels if someone updates templates manually via API
       // That's why we don't explicitly check for channel type here
@@ -300,9 +286,6 @@ export default {
     hasAttachments() {
       return this.attachedFiles.length;
     },
-    isRichEditorEnabled() {
-      return this.isAWebWidgetInbox || this.isAnEmailChannel;
-    },
     showAudioRecorder() {
       return !this.isOnPrivateNote && this.showFileUpload;
     },
@@ -342,21 +325,11 @@ export default {
       return !this.isPrivate && this.sendWithSignature;
     },
     isSignatureAvailable() {
-      return !!this.signatureToApply;
+      return !!this.messageSignature;
     },
     sendWithSignature() {
       return this.fetchSignatureFlagFromUISettings(this.channelType);
     },
-    editorMessageKey() {
-      const { editor_message_key: isEnabled } = this.uiSettings;
-      return isEnabled;
-    },
-    commandPlusEnterToSendEnabled() {
-      return this.editorMessageKey === 'cmd_enter';
-    },
-    enterToSendEnabled() {
-      return this.editorMessageKey === 'enter';
-    },
     conversationId() {
       return this.currentChat.id;
     },
@@ -383,12 +356,6 @@ export default {
       });
       return variables;
     },
-    // ensure that the signature is plain text depending on `showRichContentEditor`
-    signatureToApply() {
-      return this.showRichContentEditor
-        ? this.messageSignature
-        : extractTextFromMarkdown(this.messageSignature);
-    },
     connectedPortalSlug() {
       const { help_center: portal = {} } = this.inbox;
       const { slug = '' } = portal;
@@ -439,6 +406,19 @@ export default {
         !!this.quotedEmailText
       );
     },
+    showRichContentEditor() {
+      if (this.isOnPrivateNote || this.isRichEditorEnabled) {
+        return true;
+      }
+
+      return false;
+    },
+    // ensure that the signature is plain text depending on `showRichContentEditor`
+    signatureToApply() {
+      return this.showRichContentEditor
+        ? this.messageSignature
+        : extractTextFromMarkdown(this.messageSignature);
+    },
   },
   watch: {
     currentChat(conversation, oldConversation) {
@@ -512,7 +492,7 @@ export default {
   mounted() {
     this.getFromDraft();
     // Don't use the keyboard listener mixin here as the events here are supposed to be
-    // working even if input/textarea is focussed.
+    // working even if the editor is focussed.
     document.addEventListener('paste', this.onPaste);
     document.addEventListener('keydown', this.handleKeyEvents);
     this.setCCAndToEmailsFromLastChat();
@@ -566,28 +546,6 @@ export default {
 
       useTrack(CONVERSATION_EVENTS.INSERT_ARTICLE_LINK);
     },
-    toggleRichContentEditor() {
-      this.updateUISettings({
-        display_rich_content_editor: !this.showRichContentEditor,
-      });
-
-      const plainTextSignature = extractTextFromMarkdown(this.messageSignature);
-
-      if (!this.showRichContentEditor && this.messageSignature) {
-        // remove the old signature -> extract text from markdown -> attach new signature
-        let message = removeSignature(this.message, this.messageSignature);
-        message = extractTextFromMarkdown(message);
-        message = appendSignature(message, plainTextSignature);
-
-        this.message = message;
-      } else {
-        this.message = replaceSignature(
-          this.message,
-          plainTextSignature,
-          this.messageSignature
-        );
-      }
-    },
     toggleQuotedReply() {
       if (!this.isAnEmailChannel) {
         return;
@@ -653,7 +611,23 @@ export default {
       if (this.isPrivate) {
         return message;
       }
-
+      if (this.showRichContentEditor) {
+        const effectiveChannelType = getEffectiveChannelType(
+          this.channelType,
+          this.inbox?.medium || ''
+        );
+        return this.sendWithSignature
+          ? appendSignature(
+              message,
+              this.messageSignature,
+              effectiveChannelType
+            )
+          : removeSignature(
+              message,
+              this.messageSignature,
+              effectiveChannelType
+            );
+      }
       return this.sendWithSignature
         ? appendSignature(message, this.signatureToApply)
         : removeSignature(message, this.signatureToApply);
@@ -716,7 +690,7 @@ export default {
     onPaste(e) {
       const data = e.clipboardData.files;
       if (!this.showRichContentEditor && data.length !== 0) {
-        this.$refs.messageInput.$el.blur();
+        this.$refs.messageInput?.$el?.blur();
       }
       if (!data.length || !data[0]) {
         return;
@@ -851,7 +825,19 @@ export default {
         // if signature is enabled, append it to the message
         // appendSignature ensures that the signature is not duplicated
         // so we don't need to check if the signature is already present
-        message = appendSignature(message, this.signatureToApply);
+        if (this.showRichContentEditor) {
+          const effectiveChannelType = getEffectiveChannelType(
+            this.channelType,
+            this.inbox?.medium || ''
+          );
+          message = appendSignature(
+            message,
+            this.messageSignature,
+            effectiveChannelType
+          );
+        } else {
+          message = appendSignature(message, this.signatureToApply);
+        }
       }
 
       const updatedMessage = replaceVariablesInMessage({
@@ -908,7 +894,19 @@ export default {
       this.message = '';
       if (this.sendWithSignature && !this.isPrivate) {
         // if signature is enabled, append it to the message
-        this.message = appendSignature(this.message, this.signatureToApply);
+        if (this.showRichContentEditor) {
+          const effectiveChannelType = getEffectiveChannelType(
+            this.channelType,
+            this.inbox?.medium || ''
+          );
+          this.message = appendSignature(
+            this.message,
+            this.messageSignature,
+            effectiveChannelType
+          );
+        } else {
+          this.message = appendSignature(this.message, this.signatureToApply);
+        }
       }
       this.attachedFiles = [];
       this.isRecordingAudio = false;
@@ -926,19 +924,15 @@ export default {
     },
     toggleAudioRecorder() {
       this.isRecordingAudio = !this.isRecordingAudio;
-      this.isRecorderAudioStopped = !this.isRecordingAudio;
       if (!this.isRecordingAudio) {
         this.resetAudioRecorderInput();
       }
     },
     toggleAudioRecorderPlayPause() {
-      if (!this.isRecordingAudio) {
-        return;
-      }
-      if (!this.isRecorderAudioStopped) {
-        this.isRecorderAudioStopped = true;
+      if (!this.$refs.audioRecorderInput) return;
+      if (!this.recordingAudioState) {
         this.$refs.audioRecorderInput.stopRecording();
-      } else if (this.isRecorderAudioStopped) {
+      } else {
         this.$refs.audioRecorderInput.playPause();
       }
     },
@@ -1245,16 +1239,17 @@ export default {
         v-else
         v-model="message"
         :editor-id="editorStateId"
-        class="input"
+        class="input popover-prosemirror-menu"
         :is-private="isOnPrivateNote"
         :placeholder="messagePlaceHolder"
         :update-selection-with="updateEditorSelectionWith"
         :min-height="4"
         enable-variables
         :variables="messageVariables"
-        :signature="signatureToApply"
+        :signature="messageSignature"
         allow-signature
         :channel-type="channelType"
+        :medium="inbox.medium"
         @typing-off="onTypingOff"
         @typing-on="onTypingOn"
         @focus="onFocus"
@@ -1302,7 +1297,6 @@ export default {
       :recording-audio-state="recordingAudioState"
       :send-button-text="replyButtonLabel"
       :show-audio-recorder="showAudioRecorder"
-      :show-editor-toggle="isAPIInbox && !isOnPrivateNote"
       :show-emoji-picker="showEmojiPicker"
       :show-file-upload="showFileUpload"
       :show-quoted-reply-toggle="shouldShowQuotedReplyToggle"
@@ -1315,7 +1309,6 @@ export default {
       :new-conversation-modal-active="newConversationModalActive"
       @select-whatsapp-template="openWhatsappTemplateModal"
       @select-content-template="openContentTemplateModal"
-      @toggle-editor="toggleRichContentEditor"
       @replace-text="replaceText"
       @toggle-insert-article="toggleInsertArticle"
       @toggle-quoted-reply="toggleQuotedReply"
diff --git a/app/javascript/dashboard/constants/editor.js b/app/javascript/dashboard/constants/editor.js
index 9a99516e8..087caa99f 100644
--- a/app/javascript/dashboard/constants/editor.js
+++ b/app/javascript/dashboard/constants/editor.js
@@ -1,23 +1,143 @@
-export const MESSAGE_EDITOR_MENU_OPTIONS = [
-  'strong',
-  'em',
-  'link',
-  'undo',
-  'redo',
-  'bulletList',
-  'orderedList',
-  'code',
-];
-
-export const MESSAGE_SIGNATURE_EDITOR_MENU_OPTIONS = [
-  'strong',
-  'em',
-  'link',
-  'undo',
-  'redo',
-  'imageUpload',
-];
+// Formatting rules for different contexts (channels and special contexts)
+// marks: inline formatting (strong, em, code, link, strike)
+// nodes: block structures (bulletList, orderedList, codeBlock, blockquote)
+export const FORMATTING = {
+  // Channel formatting
+  'Channel::Email': {
+    marks: ['strong', 'em', 'code', 'link'],
+    nodes: ['bulletList', 'orderedList', 'codeBlock', 'blockquote', 'image'],
+    menu: [
+      'strong',
+      'em',
+      'code',
+      'link',
+      'bulletList',
+      'orderedList',
+      'undo',
+      'redo',
+    ],
+  },
+  'Channel::WebWidget': {
+    marks: ['strong', 'em', 'code', 'link', 'strike'],
+    nodes: ['bulletList', 'orderedList', 'codeBlock', 'blockquote', 'image'],
+    menu: [
+      'strong',
+      'em',
+      'code',
+      'link',
+      'strike',
+      'bulletList',
+      'orderedList',
+      'undo',
+      'redo',
+    ],
+  },
+  'Channel::Api': {
+    marks: ['strong', 'em'],
+    nodes: [],
+    menu: ['strong', 'em', 'undo', 'redo'],
+  },
+  'Channel::FacebookPage': {
+    marks: ['strong', 'em', 'code', 'strike'],
+    nodes: ['bulletList', 'orderedList', 'codeBlock'],
+    menu: [
+      'strong',
+      'em',
+      'code',
+      'strike',
+      'bulletList',
+      'orderedList',
+      'undo',
+      'redo',
+    ],
+  },
+  'Channel::TwitterProfile': {
+    marks: [],
+    nodes: [],
+    menu: [],
+  },
+  'Channel::TwilioSms': {
+    marks: [],
+    nodes: [],
+    menu: [],
+  },
+  'Channel::Sms': {
+    marks: [],
+    nodes: [],
+    menu: [],
+  },
+  'Channel::Whatsapp': {
+    marks: ['strong', 'em', 'code', 'strike'],
+    nodes: ['bulletList', 'orderedList', 'codeBlock'],
+    menu: [
+      'strong',
+      'em',
+      'code',
+      'strike',
+      'bulletList',
+      'orderedList',
+      'undo',
+      'redo',
+    ],
+  },
+  'Channel::Line': {
+    marks: ['strong', 'em', 'code', 'strike'],
+    nodes: ['codeBlock'],
+    menu: ['strong', 'em', 'code', 'strike', 'undo', 'redo'],
+  },
+  'Channel::Telegram': {
+    marks: ['strong', 'em', 'link', 'code'],
+    nodes: [],
+    menu: ['strong', 'em', 'link', 'code', 'undo', 'redo'],
+  },
+  'Channel::Instagram': {
+    marks: ['strong', 'em', 'code', 'strike'],
+    nodes: ['bulletList', 'orderedList'],
+    menu: [
+      'strong',
+      'em',
+      'code',
+      'bulletList',
+      'orderedList',
+      'strike',
+      'undo',
+      'redo',
+    ],
+  },
+  'Channel::Voice': {
+    marks: [],
+    nodes: [],
+    menu: [],
+  },
+  // Special contexts (not actual channels)
+  'Context::Default': {
+    marks: ['strong', 'em', 'code', 'link', 'strike'],
+    nodes: ['bulletList', 'orderedList', 'codeBlock', 'blockquote'],
+    menu: [
+      'strong',
+      'em',
+      'code',
+      'link',
+      'strike',
+      'bulletList',
+      'orderedList',
+      'undo',
+      'redo',
+    ],
+  },
+  'Context::MessageSignature': {
+    marks: ['strong', 'em', 'link'],
+    nodes: ['image'],
+    menu: ['strong', 'em', 'link', 'undo', 'redo', 'imageUpload'],
+  },
+  'Context::InboxSettings': {
+    marks: ['strong', 'em', 'link'],
+    nodes: [],
+    menu: ['strong', 'em', 'link', 'undo', 'redo'],
+  },
+};
 
+// Editor menu options for Full Editor
 export const ARTICLE_EDITOR_MENU_OPTIONS = [
   'strong',
   'em',
@@ -33,14 +153,86 @@ export const ARTICLE_EDITOR_MENU_OPTIONS = [
   'code',
 ];
 
-export const WIDGET_BUILDER_EDITOR_MENU_OPTIONS = [
-  'strong',
-  'em',
-  'link',
-  'undo',
-  'redo',
+/**
+ * Markdown formatting patterns for stripping unsupported formatting.
+ *
+ * Maps camelCase type names to ProseMirror snake_case schema names.
+ * Order matters: codeBlock before code to avoid partial matches.
+ */
+export const MARKDOWN_PATTERNS = [
+  // --- BLOCK NODES ---
+  {
+    type: 'codeBlock', // PM: code_block, eg: ```js\ncode\n```
+    patterns: [
+      { pattern: /`{3}(?:\w+)?\n?([\s\S]*?)`{3}/g, replacement: '$1' },
+    ],
+  },
+  {
+    type: 'blockquote', // PM: blockquote, eg: > quote
+    patterns: [{ pattern: /^> ?/gm, replacement: '' }],
+  },
+  {
+    type: 'bulletList', // PM: bullet_list, eg: - item
+    patterns: [{ pattern: /^[\t ]*[-*+]\s+/gm, replacement: '' }],
+  },
+  {
+    type: 'orderedList', // PM: ordered_list, eg: 1. item
+    patterns: [{ pattern: /^[\t ]*\d+\.\s+/gm, replacement: '' }],
+  },
+  {
+    type: 'heading', // PM: heading, eg: ## Heading
+    patterns: [{ pattern: /^#{1,6}\s+/gm, replacement: '' }],
+  },
+  {
+    type: 'horizontalRule', // PM: horizontal_rule, eg: ---
+    patterns: [{ pattern: /^(?:---|___|\*\*\*)\s*$/gm, replacement: '' }],
+  },
+  {
+    type: 'image', // PM: image, eg: ![alt](url)
+    patterns: [{ pattern: /!\[([^\]]*)\]\([^)]+\)/g, replacement: '$1' }],
+  },
+  {
+    type: 'hardBreak', // PM: hard_break, eg: line\\\n or line  \n
+    patterns: [
+      { pattern: /\\\n/g, replacement: '\n' },
+      { pattern: / {2,}\n/g, replacement: '\n' },
+    ],
+  },
+  // --- INLINE MARKS ---
+  {
+    type: 'strong', // PM: strong, eg: **bold** or __bold__
+    patterns: [
+      { pattern: /\*\*(.+?)\*\*/g, replacement: '$1' },
+      { pattern: /__(.+?)__/g, replacement: '$1' },
+    ],
+  },
+  {
+    type: 'em', // PM: em, eg: *italic* or _italic_
+    patterns: [
+      { pattern: /(?<!\*)\*(?!\*)(.+?)(?<!\*)\*(?!\*)/g, replacement: '$1' },
+      // Match _text_ only at word boundaries (whitespace/string start/end)
+      // Preserves underscores in URLs (e.g., https://example.com/path_name) and variable names
+      {
+        pattern: /(?<=^|[\s])_([^_\s][^_]*[^_\s]|[^_\s])_(?=$|[\s])/g,
+        replacement: '$1',
+      },
+    ],
+  },
+  {
+    type: 'strike', // PM: strike, eg: ~~strikethrough~~
+    patterns: [{ pattern: /~~(.+?)~~/g, replacement: '$1' }],
+  },
+  {
+    type: 'code', // PM: code, eg: `inline code`
+    patterns: [{ pattern: /`([^`]+)`/g, replacement: '$1' }],
+  },
+  {
+    type: 'link', // PM: link, eg: [text](url)
+    patterns: [{ pattern: /\[([^\]]+)\]\([^)]+\)/g, replacement: '$1' }],
+  },
 ];
 
+// Editor image resize options for Message Editor
 export const MESSAGE_EDITOR_IMAGE_RESIZES = [
   {
     name: 'Small',
diff --git a/app/javascript/dashboard/helper/editorHelper.js b/app/javascript/dashboard/helper/editorHelper.js
index ae4c4a8cc..1d8a97186 100644
--- a/app/javascript/dashboard/helper/editorHelper.js
+++ b/app/javascript/dashboard/helper/editorHelper.js
@@ -5,6 +5,82 @@ import {
 } from '@chatwoot/prosemirror-schema';
 import { replaceVariablesInMessage } from '@chatwoot/utils';
 import * as Sentry from '@sentry/vue';
+import { FORMATTING, MARKDOWN_PATTERNS } from 'dashboard/constants/editor';
+import { INBOX_TYPES, TWILIO_CHANNEL_MEDIUM } from 'dashboard/helper/inbox';
+import camelcaseKeys from 'camelcase-keys';
+
+/**
+ * Extract text from markdown, and remove all images, code blocks, links, headers, bold, italic, lists etc.
+ * Links will be converted to text, and not removed.
+ *
+ * @param {string} markdown - markdown text to be extracted
+ * @returns {string} - The extracted text.
+ */
+export function extractTextFromMarkdown(markdown) {
+  if (!markdown) return '';
+  return markdown
+    .replace(/```[\s\S]*?```/g, '') // Remove code blocks
+    .replace(/`.*?`/g, '') // Remove inline code
+    .replace(/!\[.*?\]\(.*?\)/g, '') // Remove images before removing links
+    .replace(/\[([^\]]+)\]\([^)]+\)/g, '$1') // Remove links but keep the text
+    .replace(/#+\s*|[*_-]{1,3}/g, '') // Remove headers, bold, italic, lists etc.
+    .split('\n')
+    .map(line => line.trim())
+    .filter(Boolean)
+    .join('\n') // Trim each line & remove any lines only having spaces
+    .replace(/\n{2,}/g, '\n') // Remove multiple consecutive newlines (blank lines)
+    .trim(); // Trim any extra space
+}
+
+/**
+ * Strip unsupported markdown formatting based on channel capabilities.
+ *
+ * @param {string} markdown - markdown text to process
+ * @param {string} channelType - The channel type to check supported formatting
+ * @returns {string} - The markdown with unsupported formatting removed
+ */
+export function stripUnsupportedSignatureMarkdown(markdown, channelType) {
+  if (!markdown) return '';
+
+  const { marks = [], nodes = [] } = FORMATTING[channelType] || {};
+  const has = (arr, key) => arr.includes(key);
+
+  // Define stripping rules: [condition, pattern, replacement]
+  const rules = [
+    [!has(nodes, 'image'), /!\[.*?\]\(.*?\)/g, ''],
+    [!has(marks, 'link'), /\[([^\]]+)\]\([^)]+\)/g, '$1'],
+    [!has(nodes, 'codeBlock'), /```[\s\S]*?```/g, ''],
+    [!has(marks, 'code'), /`([^`]+)`/g, '$1'],
+    [!has(marks, 'strong'), /\*\*([^*]+)\*\*/g, '$1'],
+    [!has(marks, 'strong'), /__([^_]+)__/g, '$1'],
+    [!has(marks, 'em'), /\*([^*]+)\*/g, '$1'],
+    // Match _text_ only at word boundaries (whitespace/string start/end)
+    // Preserves underscores in URLs (e.g., https://example.com/path_name) and variable names
+    [
+      !has(marks, 'em'),
+      /(?<=^|[\s])_([^_\s][^_]*[^_\s]|[^_\s])_(?=$|[\s])/g,
+      '$1',
+    ],
+    [!has(marks, 'strike'), /~~([^~]+)~~/g, '$1'],
+    [!has(nodes, 'blockquote'), /^>\s?/gm, ''],
+    [!has(nodes, 'bulletList'), /^[-*+]\s+/gm, ''],
+    [!has(nodes, 'orderedList'), /^\d+\.\s+/gm, ''],
+  ];
+
+  const result = rules.reduce(
+    (text, [shouldStrip, pattern, replacement]) =>
+      shouldStrip ? text.replace(pattern, replacement) : text,
+    markdown
+  );
+
+  return result
+    .split('\n')
+    .map(line => line.trim())
+    .filter(Boolean)
+    .join('\n')
+    .replace(/\n{2,}/g, '\n')
+    .trim();
+}
 
 /**
  * The delimiter used to separate the signature from the rest of the body.
@@ -67,15 +143,39 @@ export function findSignatureInBody(body, signature) {
   return -1;
 }
 
+/**
+ * Gets the effective channel type for formatting purposes.
+ * For Twilio channels, returns WhatsApp or Twilio based on medium.
+ *
+ * @param {string} channelType - The channel type
+ * @param {string} medium - Optional. The medium for Twilio channels (sms/whatsapp)
+ * @returns {string} - The effective channel type for formatting
+ */
+export function getEffectiveChannelType(channelType, medium) {
+  if (channelType === INBOX_TYPES.TWILIO) {
+    return medium === TWILIO_CHANNEL_MEDIUM.WHATSAPP
+      ? INBOX_TYPES.WHATSAPP
+      : INBOX_TYPES.TWILIO;
+  }
+  return channelType;
+}
+
 /**
  * Appends the signature to the body, separated by the signature delimiter.
+ * Automatically strips unsupported formatting based on channel capabilities.
  *
  * @param {string} body - The body to append the signature to.
  * @param {string} signature - The signature to append.
+ * @param {string} channelType - Optional. The effective channel type to determine supported formatting.
+ *                               For Twilio channels, pass the result of getEffectiveChannelType().
  * @returns {string} - The body with the signature appended.
  */
-export function appendSignature(body, signature) {
-  const cleanedSignature = cleanSignature(signature);
+export function appendSignature(body, signature, channelType) {
+  // Strip only unsupported formatting based on channel capabilities
+  const preparedSignature = channelType
+    ? stripUnsupportedSignatureMarkdown(signature, channelType)
+    : signature;
+  const cleanedSignature = cleanSignature(preparedSignature);
   // if signature is already present, return body
   if (findSignatureInBody(body, cleanedSignature) > -1) {
     return body;
@@ -86,16 +186,34 @@ export function appendSignature(body, signature) {
 
 /**
  * Removes the signature from the body, along with the signature delimiter.
+ * Tries to find both the original signature and the stripped version.
  *
  * @param {string} body - The body to remove the signature from.
  * @param {string} signature - The signature to remove.
+ * @param {string} channelType - Optional. The effective channel type for channel-specific stripping.
+ *                               For Twilio channels, pass the result of getEffectiveChannelType().
  * @returns {string} - The body with the signature removed.
  */
-export function removeSignature(body, signature) {
-  // this will find the index of the signature if it exists
-  // Regardless of extra spaces or new lines after the signature, the index will be the same if present
+export function removeSignature(body, signature, channelType) {
+  // Build list of signatures to try: original, channel-stripped, and fully stripped
   const cleanedSignature = cleanSignature(signature);
-  const signatureIndex = findSignatureInBody(body, cleanedSignature);
+  const channelStripped = channelType
+    ? cleanSignature(stripUnsupportedSignatureMarkdown(signature, channelType))
+    : null;
+  const fullyStripped = cleanSignature(extractTextFromMarkdown(signature));
+
+  // Try signatures in order: original → channel-specific → fully stripped
+  const signaturesToTry = [
+    cleanedSignature,
+    channelStripped,
+    fullyStripped,
+  ].filter((sig, i, arr) => sig && arr.indexOf(sig) === i); // Remove nulls and duplicates
+
+  // Find the first matching signature
+  const signatureIndex = signaturesToTry.reduce(
+    (index, sig) => (index === -1 ? findSignatureInBody(body, sig) : index),
+    -1
+  );
 
   // no need to trim the ends here, because it will simply be removed in the next method
   let newBody = body;
@@ -136,28 +254,6 @@ export function replaceSignature(body, oldSignature, newSignature) {
   return appendSignature(withoutSignature, newSignature);
 }
 
-/**
- * Extract text from markdown, and remove all images, code blocks, links, headers, bold, italic, lists etc.
- * Links will be converted to text, and not removed.
- *
- * @param {string} markdown - markdown text to be extracted
- * @returns
- */
-export function extractTextFromMarkdown(markdown) {
-  return markdown
-    .replace(/```[\s\S]*?```/g, '') // Remove code blocks
-    .replace(/`.*?`/g, '') // Remove inline code
-    .replace(/!\[.*?\]\(.*?\)/g, '') // Remove images before removing links
-    .replace(/\[([^\]]+)\]\([^)]+\)/g, '$1') // Remove links but keep the text
-    .replace(/#+\s*|[*_-]{1,3}/g, '') // Remove headers, bold, italic, lists etc.
-    .split('\n')
-    .map(line => line.trim())
-    .filter(Boolean)
-    .join('\n') // Trim each line & remove any lines only having spaces
-    .replace(/\n{2,}/g, '\n') // Remove multiple consecutive newlines (blank lines)
-    .trim(); // Trim any extra space
-}
-
 /**
  * Scrolls the editor view into current cursor position
  *
@@ -283,6 +379,47 @@ export function setURLWithQueryAndSize(selectedImageNode, size, editorView) {
   }
 }
 
+/**
+ * Strips unsupported markdown formatting from content based on the editor schema.
+ * This ensures canned responses with rich formatting can be inserted into channels
+ * that don't support certain formatting (e.g., API channels don't support bold).
+ *
+ * @param {string} content - The markdown content to sanitize
+ * @param {Object} schema - The ProseMirror schema with supported marks and nodes
+ * @returns {string} - Content with unsupported formatting stripped
+ */
+export function stripUnsupportedFormatting(content, schema) {
+  if (!content || typeof content !== 'string') return content;
+  if (!schema) return content;
+
+  let sanitizedContent = content;
+
+  // Get supported marks and nodes from the schema
+  // Note: ProseMirror uses snake_case internally (code_block, bullet_list, etc.)
+  // but our FORMATTING constant uses camelCase (codeBlock, bulletList, etc.)
+  // We use camelcase-keys to normalize node names for comparison
+  const supportedMarks = Object.keys(schema.marks || {});
+  const nodeKeys = Object.keys(schema.nodes || {});
+  const nodeKeysObj = Object.fromEntries(nodeKeys.map(k => [k, true]));
+  const supportedNodes = Object.keys(camelcaseKeys(nodeKeysObj));
+
+  // Process each formatting type in order (codeBlock before code is important!)
+  MARKDOWN_PATTERNS.forEach(({ type, patterns }) => {
+    // Check if this format type is supported by the schema
+    const isMarkSupported = supportedMarks.includes(type);
+    const isNodeSupported = supportedNodes.includes(type);
+
+    // If not supported, strip the formatting
+    if (!isMarkSupported && !isNodeSupported) {
+      patterns.forEach(({ pattern, replacement }) => {
+        sanitizedContent = sanitizedContent.replace(pattern, replacement);
+      });
+    }
+  });
+
+  return sanitizedContent;
+}
+
 /**
  * Content Node Creation Helper Functions for
  * - mention
@@ -313,8 +450,17 @@ const createNode = (editorView, nodeType, content) => {
 
       return mentionNode;
     }
-    case 'cannedResponse':
-      return new MessageMarkdownTransformer(messageSchema).parse(content);
+    case 'cannedResponse': {
+      // Strip unsupported formatting before parsing to ensure content can be inserted
+      // into channels that don't support certain markdown features (e.g., API channels)
+      const sanitizedContent = stripUnsupportedFormatting(
+        content,
+        state.schema
+      );
+      return new MessageMarkdownTransformer(state.schema).parse(
+        sanitizedContent
+      );
+    }
     case 'variable':
       return state.schema.text(`{{${content}}}`);
     case 'emoji':
@@ -389,3 +535,85 @@ export const getContentNode = (
     ? creator(editorView, content, from, to, variables)
     : { node: null, from, to };
 };
+
+/**
+ * Get the formatting configuration for a specific channel type.
+ * Returns the appropriate marks, nodes, and menu items for the editor.
+ *
+ * @param {string} channelType - The channel type (e.g., 'Channel::FacebookPage', 'Channel::WebWidget')
+ * @returns {Object} The formatting configuration with marks, nodes, and menu properties
+ */
+export function getFormattingForEditor(channelType) {
+  return FORMATTING[channelType] || FORMATTING['Context::Default'];
+}
+
+/**
+ * Menu Positioning Helpers
+ * Handles floating menu bar positioning for text selection in the editor.
+ */
+
+const MENU_CONFIG = { H: 46, W: 300, GAP: 10 };
+
+/**
+ * Calculate selection coordinates with bias to handle line-wraps correctly.
+ * @param {EditorView} editorView - ProseMirror editor view
+ * @param {Selection} selection - Current text selection
+ * @param {DOMRect} rect - Container bounding rect
+ * @returns {{start: Object, end: Object, selTop: number, onTop: boolean}}
+ */
+export function getSelectionCoords(editorView, selection, rect) {
+  const start = editorView.coordsAtPos(selection.from, 1);
+  const end = editorView.coordsAtPos(selection.to, -1);
+
+  const selTop = Math.min(start.top, end.top);
+  const spaceAbove = selTop - rect.top;
+  const onTop =
+    spaceAbove > MENU_CONFIG.H + MENU_CONFIG.GAP || end.bottom > rect.bottom;
+
+  return { start, end, selTop, onTop };
+}
+
+/**
+ * Calculate anchor position based on selection visibility and RTL direction.
+ * @param {Object} coords - Selection coordinates from getSelectionCoords
+ * @param {DOMRect} rect - Container bounding rect
+ * @param {boolean} isRtl - Whether text direction is RTL
+ * @returns {number} Anchor x-position for menu
+ */
+export function getMenuAnchor(coords, rect, isRtl) {
+  const { start, end, onTop } = coords;
+
+  if (!onTop) return end.left;
+
+  // If start of selection is visible, align to text. Else stick to container edge.
+  if (start.top >= rect.top) return isRtl ? start.right : start.left;
+
+  return isRtl ? rect.right - MENU_CONFIG.GAP : rect.left + MENU_CONFIG.GAP;
+}
+
+/**
+ * Calculate final menu position (left, top) within container bounds.
+ * @param {Object} coords - Selection coordinates from getSelectionCoords
+ * @param {DOMRect} rect - Container bounding rect
+ * @param {boolean} isRtl - Whether text direction is RTL
+ * @returns {{left: number, top: number, width: number}}
+ */
+export function calculateMenuPosition(coords, rect, isRtl) {
+  const { start, end, selTop, onTop } = coords;
+
+  const anchor = getMenuAnchor(coords, rect, isRtl);
+
+  // Calculate Left: shift by width if RTL, then make relative to container
+  const rawLeft = (isRtl ? anchor - MENU_CONFIG.W : anchor) - rect.left;
+
+  // Ensure menu stays within container bounds
+  const left = Math.min(Math.max(0, rawLeft), rect.width - MENU_CONFIG.W);
+
+  // Calculate Top: align to selection or bottom of selection
+  const top = onTop
+    ? Math.max(-26, selTop - rect.top - MENU_CONFIG.H - MENU_CONFIG.GAP)
+    : Math.max(start.bottom, end.bottom) - rect.top + MENU_CONFIG.GAP;
+  return { left, top, width: MENU_CONFIG.W };
+}
+
+/* End Menu Positioning Helpers */
diff --git a/app/javascript/dashboard/helper/inbox.js b/app/javascript/dashboard/helper/inbox.js
index 501375ab7..05823e8a7 100644
--- a/app/javascript/dashboard/helper/inbox.js
+++ b/app/javascript/dashboard/helper/inbox.js
@@ -13,6 +13,11 @@ export const INBOX_TYPES = {
   VOICE: 'Channel::Voice',
 };
 
+export const TWILIO_CHANNEL_MEDIUM = {
+  WHATSAPP: 'whatsapp',
+  SMS: 'sms',
+};
+
 const INBOX_ICON_MAP_FILL = {
   [INBOX_TYPES.WEB]: 'i-ri-global-fill',
   [INBOX_TYPES.FB]: 'i-ri-messenger-fill',
diff --git a/app/javascript/dashboard/helper/specs/editorContentHelper.spec.js b/app/javascript/dashboard/helper/specs/editorContentHelper.spec.js
index 56b162d50..4efb4d1d9 100644
--- a/app/javascript/dashboard/helper/specs/editorContentHelper.spec.js
+++ b/app/javascript/dashboard/helper/specs/editorContentHelper.spec.js
@@ -1,15 +1,11 @@
 // Moved from editorHelper.spec.js to editorContentHelper.spec.js
 // the mock of chatwoot/prosemirror-schema is getting conflicted with other specs
 import { getContentNode } from '../editorHelper';
-import {
-  MessageMarkdownTransformer,
-  messageSchema,
-} from '@chatwoot/prosemirror-schema';
+import { MessageMarkdownTransformer } from '@chatwoot/prosemirror-schema';
 import { replaceVariablesInMessage } from '@chatwoot/utils';
 
 vi.mock('@chatwoot/prosemirror-schema', () => ({
   MessageMarkdownTransformer: vi.fn(),
-  messageSchema: {},
 }));
 
 vi.mock('@chatwoot/utils', () => ({
@@ -62,12 +58,18 @@ describe('getContentNode', () => {
       const to = 10;
       const updatedMessage = 'Hello John';
 
-      replaceVariablesInMessage.mockReturnValue(updatedMessage);
-      MessageMarkdownTransformer.mockImplementation(() => ({
-        parse: vi.fn().mockReturnValue({ textContent: updatedMessage }),
-      }));
+      // Mock the node that will be returned by parse
+      const mockNode = { textContent: updatedMessage };
 
-      const { node } = getContentNode(
+      replaceVariablesInMessage.mockReturnValue(updatedMessage);
+
+      // Mock MessageMarkdownTransformer instance with parse method
+      const mockTransformer = {
+        parse: vi.fn().mockReturnValue(mockNode),
+      };
+      MessageMarkdownTransformer.mockImplementation(() => mockTransformer);
+
+      const result = getContentNode(
         editorView,
         'cannedResponse',
         content,
@@ -79,8 +81,15 @@ describe('getContentNode', () => {
         message: content,
         variables,
       });
-      expect(MessageMarkdownTransformer).toHaveBeenCalledWith(messageSchema);
-      expect(node.textContent).toBe(updatedMessage);
+      expect(MessageMarkdownTransformer).toHaveBeenCalledWith(
+        editorView.state.schema
+      );
+      expect(mockTransformer.parse).toHaveBeenCalledWith(updatedMessage);
+      expect(result.node).toBe(mockNode);
+      expect(result.node.textContent).toBe(updatedMessage);
+      // When textContent matches updatedMessage, from should remain unchanged
+      expect(result.from).toBe(from);
+      expect(result.to).toBe(to);
     });
   });
 
diff --git a/app/javascript/dashboard/helper/specs/editorHelper.spec.js b/app/javascript/dashboard/helper/specs/editorHelper.spec.js
index 4ed9170c2..1ae765ca7 100644
--- a/app/javascript/dashboard/helper/specs/editorHelper.spec.js
+++ b/app/javascript/dashboard/helper/specs/editorHelper.spec.js
@@ -5,11 +5,18 @@ import {
   replaceSignature,
   cleanSignature,
   extractTextFromMarkdown,
+  stripUnsupportedSignatureMarkdown,
   insertAtCursor,
   findNodeToInsertImage,
   setURLWithQueryAndSize,
   getContentNode,
+  getFormattingForEditor,
+  getSelectionCoords,
+  getMenuAnchor,
+  calculateMenuPosition,
+  stripUnsupportedFormatting,
 } from '../editorHelper';
+import { FORMATTING } from 'dashboard/constants/editor';
 import { EditorState } from '@chatwoot/prosemirror-schema';
 import { EditorView } from '@chatwoot/prosemirror-schema';
 import { Schema } from 'prosemirror-model';
@@ -138,6 +145,107 @@ describe('appendSignature', () => {
   });
 });
 
+describe('stripUnsupportedSignatureMarkdown', () => {
+  const richSignature =
+    '**Bold** _italic_ [link](http://example.com) ![](http://localhost:3000/image.png)';
+
+  it('keeps all formatting for Email channel (supports image, link, strong, em)', () => {
+    const result = stripUnsupportedSignatureMarkdown(
+      richSignature,
+      'Channel::Email'
+    );
+    expect(result).toContain('**Bold**');
+    expect(result).toContain('_italic_');
+    expect(result).toContain('[link](http://example.com)');
+    expect(result).toContain('![](http://localhost:3000/image.png)');
+  });
+  it('strips images but keeps bold/italic for Api channel', () => {
+    const result = stripUnsupportedSignatureMarkdown(
+      richSignature,
+      'Channel::Api'
+    );
+    expect(result).toContain('**Bold**');
+    expect(result).toContain('_italic_');
+    expect(result).toContain('link'); // link text kept
+    expect(result).not.toContain('[link]('); // link syntax removed
+    expect(result).not.toContain('![]('); // image removed
+  });
+  it('strips images but keeps bold/italic/link for Telegram channel', () => {
+    const result = stripUnsupportedSignatureMarkdown(
+      richSignature,
+      'Channel::Telegram'
+    );
+    expect(result).toContain('**Bold**');
+    expect(result).toContain('_italic_');
+    expect(result).toContain('[link](http://example.com)');
+    expect(result).not.toContain('![](');
+  });
+  it('strips all formatting for SMS channel', () => {
+    const result = stripUnsupportedSignatureMarkdown(
+      richSignature,
+      'Channel::Sms'
+    );
+    expect(result).toContain('Bold');
+    expect(result).toContain('italic');
+    expect(result).toContain('link');
+    expect(result).not.toContain('**');
+    expect(result).not.toContain('_');
+    expect(result).not.toContain('[');
+    expect(result).not.toContain('![](');
+  });
+  it('returns empty string for empty input', () => {
+    expect(stripUnsupportedSignatureMarkdown('', 'Channel::Api')).toBe('');
+    expect(stripUnsupportedSignatureMarkdown(null, 'Channel::Api')).toBe('');
+  });
+});
+
+describe('appendSignature with channelType', () => {
+  const signatureWithImage =
+    'Thanks\n![](http://localhost:3000/image.png?cw_image_height=24px)';
+
+  it('keeps images for Email channel', () => {
+    const result = appendSignature(
+      'Hello',
+      signatureWithImage,
+      'Channel::Email'
+    );
+    expect(result).toContain('![](http://localhost:3000/image.png');
+  });
+  it('keeps images for WebWidget channel', () => {
+    const result = appendSignature(
+      'Hello',
+      signatureWithImage,
+      'Channel::WebWidget'
+    );
+    expect(result).toContain('![](http://localhost:3000/image.png');
+  });
+  it('strips images but keeps text for Api channel', () => {
+    const result = appendSignature('Hello', signatureWithImage, 'Channel::Api');
+    expect(result).not.toContain('![](');
+    expect(result).toContain('Thanks');
+  });
+  it('strips images but keeps text for WhatsApp channel', () => {
+    const result = appendSignature(
+      'Hello',
+      signatureWithImage,
+      'Channel::Whatsapp'
+    );
+    expect(result).not.toContain('![](');
+    expect(result).toContain('Thanks');
+  });
+  it('keeps images when channelType is not provided', () => {
+    const result = appendSignature('Hello', signatureWithImage);
+    expect(result).toContain('![](http://localhost:3000/image.png');
+  });
+  it('keeps bold/italic for channels that support them', () => {
+    const boldSignature = '**Bold** *italic* Thanks';
+    const result = appendSignature('Hello', boldSignature, 'Channel::Api');
+    // Api supports strong and em
+    expect(result).toContain('**Bold**');
+    expect(result).toContain('*italic*');
+  });
+});
+
 describe('cleanSignature', () => {
   it('removes any instance of horizontal rule', () => {
     const options = [
@@ -196,6 +304,37 @@ describe('removeSignature', () => {
   });
 });
 
+describe('removeSignature with stripped signature', () => {
+  const signatureWithImage =
+    'Thanks\n![](http://localhost:3000/image.png?cw_image_height=24px)';
+
+  it('removes stripped signature from body', () => {
+    // Simulate a body where signature was added with images stripped
+    const bodyWithStrippedSignature = 'Hello\n\n--\n\nThanks';
+    const result = removeSignature(
+      bodyWithStrippedSignature,
+      signatureWithImage
+    );
+    expect(result).toBe('Hello\n\n');
+  });
+  it('removes original signature from body', () => {
+    // Simulate a body where signature was added with images (using cleanSignature format)
+    const cleanedSig = cleanSignature(signatureWithImage);
+    const bodyWithOriginalSignature = `Hello\n\n--\n\n${cleanedSig}`;
+    const result = removeSignature(
+      bodyWithOriginalSignature,
+      signatureWithImage
+    );
+    expect(result).toBe('Hello\n\n');
+  });
+  it('handles signature without images', () => {
+    const simpleSignature = 'Best regards';
+    const body = 'Hello\n\n--\n\nBest regards';
+    const result = removeSignature(body, simpleSignature);
+    expect(result).toBe('Hello\n\n');
+  });
+});
+
 describe('replaceSignature', () => {
   it('appends the new signature if not present', () => {
     Object.keys(DOES_NOT_HAVE_SIGNATURE).forEach(key => {
@@ -258,15 +397,11 @@ describe('insertAtCursor', () => {
     expect(result).toBeUndefined();
   });
 
-  it('should unwrap doc nodes that are wrapped in a paragraph', () => {
-    const docNode = schema.node('doc', null, [
-      schema.node('paragraph', null, [schema.text('Hello')]),
-    ]);
-
+  it('should insert text node at cursor position', () => {
     const editorState = createEditorState();
     const editorView = new EditorView(document.body, { state: editorState });
 
-    insertAtCursor(editorView, docNode, 0);
+    insertAtCursor(editorView, schema.text('Hello'), 0);
 
     // Check if node was unwrapped and inserted correctly
     expect(editorView.state.doc.firstChild.firstChild.text).toBe('Hello');
@@ -626,3 +761,349 @@ describe('getContentNode', () => {
     });
   });
 });
+
+describe('getFormattingForEditor', () => {
+  describe('channel-specific formatting', () => {
+    it('returns full formatting for Email channel', () => {
+      const result = getFormattingForEditor('Channel::Email');
+
+      expect(result).toEqual(FORMATTING['Channel::Email']);
+    });
+
+    it('returns full formatting for WebWidget channel', () => {
+      const result = getFormattingForEditor('Channel::WebWidget');
+
+      expect(result).toEqual(FORMATTING['Channel::WebWidget']);
+    });
+
+    it('returns limited formatting for WhatsApp channel', () => {
+      const result = getFormattingForEditor('Channel::Whatsapp');
+
+      expect(result).toEqual(FORMATTING['Channel::Whatsapp']);
+    });
+
+    it('returns no formatting for API channel', () => {
+      const result = getFormattingForEditor('Channel::Api');
+
+      expect(result).toEqual(FORMATTING['Channel::Api']);
+    });
+
+    it('returns limited formatting for FacebookPage channel', () => {
+      const result = getFormattingForEditor('Channel::FacebookPage');
+
+      expect(result).toEqual(FORMATTING['Channel::FacebookPage']);
+    });
+
+    it('returns no formatting for TwitterProfile channel', () => {
+      const result = getFormattingForEditor('Channel::TwitterProfile');
+
+      expect(result).toEqual(FORMATTING['Channel::TwitterProfile']);
+    });
+
+    it('returns no formatting for SMS channel', () => {
+      const result = getFormattingForEditor('Channel::Sms');
+
+      expect(result).toEqual(FORMATTING['Channel::Sms']);
+    });
+
+    it('returns limited formatting for Telegram channel', () => {
+      const result = getFormattingForEditor('Channel::Telegram');
+
+      expect(result).toEqual(FORMATTING['Channel::Telegram']);
+    });
+
+    it('returns formatting for Instagram channel', () => {
+      const result = getFormattingForEditor('Channel::Instagram');
+
+      expect(result).toEqual(FORMATTING['Channel::Instagram']);
+    });
+  });
+
+  describe('context-specific formatting', () => {
+    it('returns default formatting for Context::Default', () => {
+      const result = getFormattingForEditor('Context::Default');
+
+      expect(result).toEqual(FORMATTING['Context::Default']);
+    });
+
+    it('returns signature formatting for Context::MessageSignature', () => {
+      const result = getFormattingForEditor('Context::MessageSignature');
+
+      expect(result).toEqual(FORMATTING['Context::MessageSignature']);
+    });
+
+    it('returns widget builder formatting for Context::InboxSettings', () => {
+      const result = getFormattingForEditor('Context::InboxSettings');
+
+      expect(result).toEqual(FORMATTING['Context::InboxSettings']);
+    });
+  });
+
+  describe('fallback behavior', () => {
+    it('returns default formatting for unknown channel type', () => {
+      const result = getFormattingForEditor('Channel::Unknown');
+
+      expect(result).toEqual(FORMATTING['Context::Default']);
+    });
+
+    it('returns default formatting for null channel type', () => {
+      const result = getFormattingForEditor(null);
+
+      expect(result).toEqual(FORMATTING['Context::Default']);
+    });
+
+    it('returns default formatting for undefined channel type', () => {
+      const result = getFormattingForEditor(undefined);
+
+      expect(result).toEqual(FORMATTING['Context::Default']);
+    });
+
+    it('returns default formatting for empty string', () => {
+      const result = getFormattingForEditor('');
+
+      expect(result).toEqual(FORMATTING['Context::Default']);
+    });
+  });
+
+  describe('return value structure', () => {
+    it('always returns an object with marks, nodes, and menu properties', () => {
+      const result = getFormattingForEditor('Channel::Email');
+
+      expect(result).toHaveProperty('marks');
+      expect(result).toHaveProperty('nodes');
+      expect(result).toHaveProperty('menu');
+      expect(Array.isArray(result.marks)).toBe(true);
+      expect(Array.isArray(result.nodes)).toBe(true);
+      expect(Array.isArray(result.menu)).toBe(true);
+    });
+  });
+});
+
+describe('stripUnsupportedFormatting', () => {
+  describe('when schema supports all formatting', () => {
+    const fullSchema = {
+      marks: { strong: {}, em: {}, code: {}, strike: {}, link: {} },
+      nodes: { bulletList: {}, orderedList: {}, codeBlock: {}, blockquote: {} },
+    };
+
+    it('preserves all formatting when schema supports it', () => {
+      const content = '**bold** and *italic* and `code`';
+      expect(stripUnsupportedFormatting(content, fullSchema)).toBe(content);
+    });
+
+    it('preserves links when schema supports them', () => {
+      const content = 'Check [this link](https://example.com)';
+      expect(stripUnsupportedFormatting(content, fullSchema)).toBe(content);
+    });
+
+    it('preserves lists when schema supports them', () => {
+      const content = '- item 1\n- item 2\n1. first\n2. second';
+      expect(stripUnsupportedFormatting(content, fullSchema)).toBe(content);
+    });
+  });
+
+  describe('when schema has no formatting support (eg:SMS channel)', () => {
+    const emptySchema = {
+      marks: {},
+      nodes: {},
+    };
+
+    it('strips bold formatting', () => {
+      expect(stripUnsupportedFormatting('**bold text**', emptySchema)).toBe(
+        'bold text'
+      );
+      expect(stripUnsupportedFormatting('__bold text__', emptySchema)).toBe(
+        'bold text'
+      );
+    });
+
+    it('strips italic formatting', () => {
+      expect(stripUnsupportedFormatting('*italic text*', emptySchema)).toBe(
+        'italic text'
+      );
+      expect(stripUnsupportedFormatting('_italic text_', emptySchema)).toBe(
+        'italic text'
+      );
+    });
+
+    it('preserves underscores in URLs and mid-word positions', () => {
+      // Underscores in URLs should not be stripped as italic formatting
+      expect(
+        stripUnsupportedFormatting(
+          'https://www.chatwoot.com/new_first_second-third/ssd',
+          emptySchema
+        )
+      ).toBe('https://www.chatwoot.com/new_first_second-third/ssd');
+
+      // Underscores in variable names should not be stripped
+      expect(
+        stripUnsupportedFormatting('some_variable_name', emptySchema)
+      ).toBe('some_variable_name');
+
+      // But actual italic formatting with spaces should still be stripped
+      expect(
+        stripUnsupportedFormatting('hello _world_ there', emptySchema)
+      ).toBe('hello world there');
+    });
+
+    it('strips inline code formatting', () => {
+      expect(stripUnsupportedFormatting('`inline code`', emptySchema)).toBe(
+        'inline code'
+      );
+    });
+
+    it('strips strikethrough formatting', () => {
+      expect(stripUnsupportedFormatting('~~strikethrough~~', emptySchema)).toBe(
+        'strikethrough'
+      );
+    });
+
+    it('strips links but keeps text', () => {
+      expect(
+        stripUnsupportedFormatting(
+          'Check [this link](https://example.com)',
+          emptySchema
+        )
+      ).toBe('Check this link');
+    });
+
+    it('strips bullet list markers', () => {
+      expect(
+        stripUnsupportedFormatting('- item 1\n- item 2', emptySchema)
+      ).toBe('item 1\nitem 2');
+      expect(
+        stripUnsupportedFormatting('* item 1\n* item 2', emptySchema)
+      ).toBe('item 1\nitem 2');
+    });
+
+    it('strips ordered list markers', () => {
+      expect(
+        stripUnsupportedFormatting('1. first\n2. second', emptySchema)
+      ).toBe('first\nsecond');
+    });
+
+    it('strips code block markers', () => {
+      expect(
+        stripUnsupportedFormatting('```javascript\ncode here\n```', emptySchema)
+      ).toBe('code here\n');
+    });
+
+    it('strips blockquote markers', () => {
+      expect(stripUnsupportedFormatting('> quoted text', emptySchema)).toBe(
+        'quoted text'
+      );
+    });
+
+    it('handles complex content with multiple formatting types', () => {
+      const content =
+        '**Bold** and *italic* with `code` and [link](url)\n- list item';
+      const expected = 'Bold and italic with code and link\nlist item';
+      expect(stripUnsupportedFormatting(content, emptySchema)).toBe(expected);
+    });
+  });
+
+  describe('when schema has partial support', () => {
+    const partialSchema = {
+      marks: { strong: {}, em: {} },
+      nodes: {},
+    };
+
+    it('preserves supported marks and strips unsupported ones', () => {
+      const content = '**bold** and `code`';
+      expect(stripUnsupportedFormatting(content, partialSchema)).toBe(
+        '**bold** and code'
+      );
+    });
+
+    it('strips unsupported nodes but keeps supported marks', () => {
+      const content = '**bold** text\n- list item';
+      expect(stripUnsupportedFormatting(content, partialSchema)).toBe(
+        '**bold** text\nlist item'
+      );
+    });
+  });
+
+  describe('edge cases', () => {
+    it('returns content unchanged if content is empty', () => {
+      expect(stripUnsupportedFormatting('', {})).toBe('');
+    });
+
+    it('returns content unchanged if content is null', () => {
+      expect(stripUnsupportedFormatting(null, {})).toBe(null);
+    });
+
+    it('returns content unchanged if content is undefined', () => {
+      expect(stripUnsupportedFormatting(undefined, {})).toBe(undefined);
+    });
+
+    it('returns content unchanged if schema is null', () => {
+      expect(stripUnsupportedFormatting('**bold**', null)).toBe('**bold**');
+    });
+
+    it('handles nested formatting correctly', () => {
+      const emptySchema = { marks: {}, nodes: {} };
+      // After stripping bold (**), the remaining *and italic* becomes italic and is stripped too
+      expect(
+        stripUnsupportedFormatting('**bold *and italic***', emptySchema)
+      ).toBe('bold and italic');
+    });
+  });
+});
+
+describe('Menu positioning helpers', () => {
+  const mockEditorView = {
+    coordsAtPos: vi.fn((pos, bias) => {
+      // Return different coords based on position
+      if (bias === 1) return { top: 100, bottom: 120, left: 50, right: 100 };
+      return { top: 100, bottom: 120, left: 150, right: 200 };
+    }),
+  };
+
+  const wrapperRect = { top: 50, bottom: 300, left: 0, right: 400, width: 400 };
+
+  describe('getSelectionCoords', () => {
+    it('returns selection coordinates with onTop flag', () => {
+      const selection = { from: 0, to: 10 };
+      const result = getSelectionCoords(mockEditorView, selection, wrapperRect);
+
+      expect(result).toHaveProperty('start');
+      expect(result).toHaveProperty('end');
+      expect(result).toHaveProperty('selTop');
+      expect(result).toHaveProperty('onTop');
+    });
+  });
+
+  describe('getMenuAnchor', () => {
+    it('returns end.left when menu is below selection', () => {
+      const coords = { start: { left: 50 }, end: { left: 150 }, onTop: false };
+      expect(getMenuAnchor(coords, wrapperRect, false)).toBe(150);
+    });
+
+    it('returns start.left for LTR when menu is above and visible', () => {
+      const coords = { start: { top: 100, left: 50 }, end: {}, onTop: true };
+      expect(getMenuAnchor(coords, wrapperRect, false)).toBe(50);
+    });
+
+    it('returns start.right for RTL when menu is above and visible', () => {
+      const coords = { start: { top: 100, right: 100 }, end: {}, onTop: true };
+      expect(getMenuAnchor(coords, wrapperRect, true)).toBe(100);
+    });
+  });
+
+  describe('calculateMenuPosition', () => {
+    it('returns bounded left and top positions', () => {
+      const coords = {
+        start: { top: 100, bottom: 120, left: 50 },
+        end: { top: 100, bottom: 120, left: 150 },
+        selTop: 100,
+        onTop: false,
+      };
+      const result = calculateMenuPosition(coords, wrapperRect, false);
+
+      expect(result).toHaveProperty('left');
+      expect(result).toHaveProperty('top');
+      expect(result).toHaveProperty('width', 300);
+      expect(result.left).toBeGreaterThanOrEqual(0);
+    });
+  });
+});
diff --git a/app/javascript/dashboard/i18n/locale/en/conversation.json b/app/javascript/dashboard/i18n/locale/en/conversation.json
index 79d5ebc66..cfb41615b 100644
--- a/app/javascript/dashboard/i18n/locale/en/conversation.json
+++ b/app/javascript/dashboard/i18n/locale/en/conversation.json
@@ -196,7 +196,6 @@
       "INSERT_READ_MORE": "Read more",
       "DISMISS_REPLY": "Dismiss reply",
       "REPLYING_TO": "Replying to:",
-      "TIP_FORMAT_ICON": "Show rich text editor",
       "TIP_EMOJI_ICON": "Show emoji selector",
       "TIP_ATTACH_ICON": "Attach files",
       "TIP_AUDIORECORDER_ICON": "Record audio",
diff --git a/app/javascript/dashboard/routes/dashboard/conversation/ContactPanel.vue b/app/javascript/dashboard/routes/dashboard/conversation/ContactPanel.vue
index 17e8dfd25..b163bfdc8 100644
--- a/app/javascript/dashboard/routes/dashboard/conversation/ContactPanel.vue
+++ b/app/javascript/dashboard/routes/dashboard/conversation/ContactPanel.vue
@@ -5,7 +5,9 @@ import {
   useFunctionGetter,
   useStore,
 } from 'dashboard/composables/store';
+import { useAccount } from 'dashboard/composables/useAccount';
 import { useUISettings } from 'dashboard/composables/useUISettings';
+import { FEATURE_FLAGS } from 'dashboard/featureFlags';
 
 import AccordionItem from 'dashboard/components/Accordion/AccordionItem.vue';
 import ContactConversations from './ContactConversations.vue';
@@ -52,12 +54,22 @@ const isShopifyFeatureEnabled = computed(
   () => shopifyIntegration.value.enabled
 );
 
+const { isCloudFeatureEnabled } = useAccount();
+
+const isLinearFeatureEnabled = computed(() =>
+  isCloudFeatureEnabled(FEATURE_FLAGS.LINEAR)
+);
+
 const linearIntegration = useFunctionGetter(
   'integrations/getIntegration',
   'linear'
 );
 
-const isLinearIntegrationEnabled = computed(
+const isLinearClientIdConfigured = computed(() => {
+  return !!linearIntegration.value?.id;
+});
+
+const isLinearConnected = computed(
   () => linearIntegration.value?.enabled || false
 );
 
@@ -238,7 +250,13 @@ onMounted(() => {
               <MacrosList :conversation-id="conversationId" />
             </AccordionItem>
           </woot-feature-toggle>
-          <div v-else-if="element.name === 'linear_issues'">
+          <div
+            v-else-if="
+              element.name === 'linear_issues' &&
+              isLinearFeatureEnabled &&
+              isLinearClientIdConfigured
+            "
+          >
             <AccordionItem
               :title="$t('CONVERSATION_SIDEBAR.ACCORDION.LINEAR_ISSUES')"
               :is-open="isContactSidebarItemOpen('is_linear_issues_open')"
@@ -247,7 +265,7 @@ onMounted(() => {
                 value => toggleSidebarUIState('is_linear_issues_open', value)
               "
             >
-              <LinearSetupCTA v-if="!isLinearIntegrationEnabled" />
+              <LinearSetupCTA v-if="!isLinearConnected" />
               <LinearIssuesList v-else :conversation-id="conversationId" />
             </AccordionItem>
           </div>
diff --git a/app/javascript/dashboard/routes/dashboard/settings/canned/AddCanned.vue b/app/javascript/dashboard/routes/dashboard/settings/canned/AddCanned.vue
index 3ec03d5ef..56caa2558 100644
--- a/app/javascript/dashboard/routes/dashboard/settings/canned/AddCanned.vue
+++ b/app/javascript/dashboard/routes/dashboard/settings/canned/AddCanned.vue
@@ -110,6 +110,7 @@ export default {
               v-model="content"
               class="message-editor [&>div]:px-1"
               :class="{ editor_warning: v$.content.$error }"
+              channel-type="Context::Default"
               enable-variables
               :enable-canned-responses="false"
               :placeholder="$t('CANNED_MGMT.ADD.FORM.CONTENT.PLACEHOLDER')"
diff --git a/app/javascript/dashboard/routes/dashboard/settings/canned/EditCanned.vue b/app/javascript/dashboard/routes/dashboard/settings/canned/EditCanned.vue
index 26a590ed3..d2c906511 100644
--- a/app/javascript/dashboard/routes/dashboard/settings/canned/EditCanned.vue
+++ b/app/javascript/dashboard/routes/dashboard/settings/canned/EditCanned.vue
@@ -114,6 +114,7 @@ export default {
               v-model="content"
               class="message-editor [&>div]:px-1"
               :class="{ editor_warning: v$.content.$error }"
+              channel-type="Context::Default"
               enable-variables
               :enable-canned-responses="false"
               :placeholder="$t('CANNED_MGMT.EDIT.FORM.CONTENT.PLACEHOLDER')"
diff --git a/app/javascript/dashboard/routes/dashboard/settings/inbox/Settings.vue b/app/javascript/dashboard/routes/dashboard/settings/inbox/Settings.vue
index bbd0d9000..6a10d0986 100644
--- a/app/javascript/dashboard/routes/dashboard/settings/inbox/Settings.vue
+++ b/app/javascript/dashboard/routes/dashboard/settings/inbox/Settings.vue
@@ -27,7 +27,6 @@ import { FEATURE_FLAGS } from '../../../../featureFlags';
 import SenderNameExamplePreview from './components/SenderNameExamplePreview.vue';
 import NextButton from 'dashboard/components-next/button/Button.vue';
 import { INBOX_TYPES } from 'dashboard/helper/inbox';
-import { WIDGET_BUILDER_EDITOR_MENU_OPTIONS } from 'dashboard/constants/editor';
 import { getInboxIconByType } from 'dashboard/helper/inbox';
 import Editor from 'dashboard/components-next/Editor/Editor.vue';
 
@@ -81,7 +80,6 @@ export default {
       selectedTabIndex: 0,
       selectedPortalSlug: '',
       showBusinessNameInput: false,
-      welcomeTaglineEditorMenuOptions: WIDGET_BUILDER_EDITOR_MENU_OPTIONS,
       healthData: null,
       isLoadingHealth: false,
       healthError: null,
@@ -626,7 +624,7 @@ export default {
               )
             "
             :max-length="255"
-            :enabled-menu-options="welcomeTaglineEditorMenuOptions"
+            channel-type="Context::InboxSettings"
           />
 
           <label v-if="isAWebWidgetInbox" class="pb-4">
diff --git a/app/javascript/dashboard/routes/dashboard/settings/inbox/WidgetBuilder.vue b/app/javascript/dashboard/routes/dashboard/settings/inbox/WidgetBuilder.vue
index 08f536185..f2d1d8fa2 100644
--- a/app/javascript/dashboard/routes/dashboard/settings/inbox/WidgetBuilder.vue
+++ b/app/javascript/dashboard/routes/dashboard/settings/inbox/WidgetBuilder.vue
@@ -7,7 +7,6 @@ import { useVuelidate } from '@vuelidate/core';
 import { required } from '@vuelidate/validators';
 import { LOCAL_STORAGE_KEYS } from 'dashboard/constants/localStorage';
 import { LocalStorage } from 'shared/helpers/localStorage';
-import { WIDGET_BUILDER_EDITOR_MENU_OPTIONS } from 'dashboard/constants/editor';
 import NextButton from 'dashboard/components-next/button/Button.vue';
 import Avatar from 'next/avatar/Avatar.vue';
 import Editor from 'dashboard/components-next/Editor/Editor.vue';
@@ -76,7 +75,6 @@ export default {
           checked: false,
         },
       ],
-      welcomeTaglineEditorMenuOptions: WIDGET_BUILDER_EDITOR_MENU_OPTIONS,
     };
   },
   computed: {
@@ -337,7 +335,7 @@ export default {
                 )
               "
               :max-length="255"
-              :enabled-menu-options="welcomeTaglineEditorMenuOptions"
+              channel-type="Context::InboxSettings"
               class="mb-4"
             />
             <label>
diff --git a/app/javascript/dashboard/routes/dashboard/settings/inbox/channels/Website.vue b/app/javascript/dashboard/routes/dashboard/settings/inbox/channels/Website.vue
index 6f21acd52..9b5907120 100644
--- a/app/javascript/dashboard/routes/dashboard/settings/inbox/channels/Website.vue
+++ b/app/javascript/dashboard/routes/dashboard/settings/inbox/channels/Website.vue
@@ -5,7 +5,6 @@ import router from '../../../../index';
 import NextButton from 'dashboard/components-next/button/Button.vue';
 import PageHeader from '../../SettingsSubPageHeader.vue';
 import GreetingsEditor from 'shared/components/GreetingsEditor.vue';
-import { WIDGET_BUILDER_EDITOR_MENU_OPTIONS } from 'dashboard/constants/editor';
 import Editor from 'dashboard/components-next/Editor/Editor.vue';
 
 export default {
@@ -24,7 +23,6 @@ export default {
       channelWelcomeTagline: '',
       greetingEnabled: false,
       greetingMessage: '',
-      welcomeTaglineEditorMenuOptions: WIDGET_BUILDER_EDITOR_MENU_OPTIONS,
     };
   },
   computed: {
@@ -147,7 +145,7 @@ export default {
           )
         "
         :max-length="255"
-        :enabled-menu-options="welcomeTaglineEditorMenuOptions"
+        channel-type="Context::InboxSettings"
         class="mb-4"
       />
 
diff --git a/app/javascript/dashboard/routes/dashboard/settings/profile/MessageSignature.vue b/app/javascript/dashboard/routes/dashboard/settings/profile/MessageSignature.vue
index ffb1ff9e7..fbaed06c1 100644
--- a/app/javascript/dashboard/routes/dashboard/settings/profile/MessageSignature.vue
+++ b/app/javascript/dashboard/routes/dashboard/settings/profile/MessageSignature.vue
@@ -1,7 +1,6 @@
 <script setup>
 import { ref, watch } from 'vue';
 import WootMessageEditor from 'dashboard/components/widgets/WootWriter/Editor.vue';
-import { MESSAGE_SIGNATURE_EDITOR_MENU_OPTIONS } from 'dashboard/constants/editor';
 import NextButton from 'dashboard/components-next/button/Button.vue';
 
 const props = defineProps({
@@ -12,7 +11,6 @@ const props = defineProps({
 });
 
 const emit = defineEmits(['updateSignature']);
-const customEditorMenuList = MESSAGE_SIGNATURE_EDITOR_MENU_OPTIONS;
 const signature = ref(props.messageSignature);
 watch(
   () => props.messageSignature ?? '',
@@ -34,7 +32,7 @@ const updateSignature = () => {
       class="message-editor h-[10rem] !px-3"
       is-format-mode
       :placeholder="$t('PROFILE_SETTINGS.FORM.MESSAGE_SIGNATURE.PLACEHOLDER')"
-      :enabled-menu-options="customEditorMenuList"
+      channel-type="Context::MessageSignature"
       :enable-suggestions="false"
       show-image-resize-toolbar
     />
diff --git a/app/javascript/shared/components/ResizableTextArea.vue b/app/javascript/shared/components/ResizableTextArea.vue
index 4dda62cf9..78318fb49 100644
--- a/app/javascript/shared/components/ResizableTextArea.vue
+++ b/app/javascript/shared/components/ResizableTextArea.vue
@@ -111,10 +111,15 @@ export default {
     // watcher, this means that if the value is true, the signature
     // is supposed to be added, else we remove it.
     toggleSignatureInEditor(signatureEnabled) {
-      const valueWithSignature = signatureEnabled
+      let valueWithSignature = signatureEnabled
         ? appendSignature(this.modelValue, this.cleanedSignature)
         : removeSignature(this.modelValue, this.cleanedSignature);
 
+      // Clean up whitespace when removing signature from empty body
+      if (!signatureEnabled && !valueWithSignature.trim()) {
+        valueWithSignature = '';
+      }
+
       this.$emit('update:modelValue', valueWithSignature);
       this.$emit('input', valueWithSignature);
 
diff --git a/app/jobs/delete_object_job.rb b/app/jobs/delete_object_job.rb
index 756d0feb1..4e9030012 100644
--- a/app/jobs/delete_object_job.rb
+++ b/app/jobs/delete_object_job.rb
@@ -2,10 +2,6 @@ class DeleteObjectJob < ApplicationJob
   queue_as :low
 
   BATCH_SIZE = 5_000
-  HEAVY_ASSOCIATIONS = {
-    Account => %i[conversations contacts inboxes reporting_events],
-    Inbox => %i[conversations contact_inboxes reporting_events]
-  }.freeze
 
   def perform(object, user = nil, ip = nil)
     # Pre-purge heavy associations for large objects to avoid
@@ -19,11 +15,18 @@ class DeleteObjectJob < ApplicationJob
 
   private
 
+  def heavy_associations
+    {
+      Account => %i[conversations contacts inboxes reporting_events],
+      Inbox => %i[conversations contact_inboxes reporting_events]
+    }.freeze
+  end
+
   def purge_heavy_associations(object)
-    klass = HEAVY_ASSOCIATIONS.keys.find { |k| object.is_a?(k) }
+    klass = heavy_associations.keys.find { |k| object.is_a?(k) }
     return unless klass
 
-    HEAVY_ASSOCIATIONS[klass].each do |assoc|
+    heavy_associations[klass].each do |assoc|
       next unless object.respond_to?(assoc)
 
       batch_destroy(object.public_send(assoc))
diff --git a/app/models/channel/telegram.rb b/app/models/channel/telegram.rb
index b18c6dbc9..07185102a 100644
--- a/app/models/channel/telegram.rb
+++ b/app/models/channel/telegram.rb
@@ -130,30 +130,39 @@ class Channel::Telegram < ApplicationRecord
   def convert_markdown_to_telegram_html(text)
     # ref: https://core.telegram.org/bots/api#html-style
 
-    # escape html tags in text. We are subbing \n to <br> since commonmark will strip exta '\n'
-    text = CGI.escapeHTML(text.gsub("\n", '<br>'))
+    # Escape HTML entities first to prevent HTML injection
+    # This ensures only markdown syntax is converted, not raw HTML
+    escaped_text = CGI.escapeHTML(text)
 
-    # convert markdown to html
-    html = CommonMarker.render_html(text).strip
+    # Parse markdown with extensions:
+    # - strikethrough: support ~~text~~
+    # - hardbreaks: preserve all newlines as <br>
+    html = CommonMarker.render_html(escaped_text, [:HARDBREAKS], [:strikethrough]).strip
 
-    # remove all html tags except b, strong, i, em, u, ins, s, strike, del, a, code, pre, blockquote
-    stripped_html = Rails::HTML5::SafeListSanitizer.new.sanitize(html, tags: %w[b strong i em u ins s strike del a code pre blockquote],
-                                                                       attributes: %w[href])
+    # Convert paragraph breaks to double newlines to preserve them
+    # CommonMarker creates <p> tags for paragraph breaks, but Telegram doesn't support <p>
+    html_with_breaks = html.gsub(%r{</p>\s*<p>}, "\n\n")
 
-    # converted escaped br tags to \n
-    stripped_html.gsub('&lt;br&gt;', "\n")
+    # Remove opening and closing <p> tags
+    html_with_breaks = html_with_breaks.gsub(%r{</?p>}, '')
+
+    # Sanitize to only allowed tags
+    stripped_html = Rails::HTML5::SafeListSanitizer.new.sanitize(html_with_breaks, tags: %w[b strong i em u ins s strike del a code pre blockquote],
+                                                                                   attributes: %w[href])
+
+    # Convert <br /> tags to newlines for Telegram
+    stripped_html.gsub(%r{<br\s*/?>}, "\n")
   end
 
   def message_request(chat_id, text, reply_markup = nil, reply_to_message_id = nil, business_connection_id: nil)
-    text_payload = convert_markdown_to_telegram_html(text)
-
+    # text is already converted to HTML by MessageContentPresenter
     business_body = {}
     business_body[:business_connection_id] = business_connection_id if business_connection_id
 
     HTTParty.post("#{telegram_api_url}/sendMessage",
                   body: {
                     chat_id: chat_id,
-                    text: text_payload,
+                    text: text,
                     reply_markup: reply_markup,
                     parse_mode: 'HTML',
                     reply_to_message_id: reply_to_message_id
diff --git a/app/models/integrations/app.rb b/app/models/integrations/app.rb
index 6a1378f1e..5e4d28c06 100644
--- a/app/models/integrations/app.rb
+++ b/app/models/integrations/app.rb
@@ -53,7 +53,7 @@ class Integrations::App
     when 'slack'
       GlobalConfigService.load('SLACK_CLIENT_SECRET', nil).present?
     when 'linear'
-      GlobalConfigService.load('LINEAR_CLIENT_ID', nil).present?
+      account.feature_enabled?('linear_integration') && GlobalConfigService.load('LINEAR_CLIENT_ID', nil).present?
     when 'shopify'
       shopify_enabled?(account)
     when 'leadsquared'
diff --git a/app/models/message.rb b/app/models/message.rb
index 2faba1215..0bf7a176b 100644
--- a/app/models/message.rb
+++ b/app/models/message.rb
@@ -254,6 +254,21 @@ class Message < ApplicationRecord
     Messages::SearchDataPresenter.new(self).search_data
   end
 
+  # Returns message content suitable for LLM consumption
+  # Falls back to audio transcription or attachment placeholder when content is nil
+  def content_for_llm
+    return content if content.present?
+
+    audio_transcription = attachments
+                          .where(file_type: :audio)
+                          .filter_map { |att| att.meta&.dig('transcribed_text') }
+                          .join(' ')
+                          .presence
+    return "[Voice Message] #{audio_transcription}" if audio_transcription.present?
+
+    '[Attachment]' if attachments.any?
+  end
+
   private
 
   def prevent_message_flooding
diff --git a/app/presenters/message_content_presenter.rb b/app/presenters/message_content_presenter.rb
index 016e5caea..fa05d4ae9 100644
--- a/app/presenters/message_content_presenter.rb
+++ b/app/presenters/message_content_presenter.rb
@@ -1,11 +1,18 @@
 class MessageContentPresenter < SimpleDelegator
   def outgoing_content
-    return content unless should_append_survey_link?
+    content_to_send = if should_append_survey_link?
+                        survey_link = survey_url(conversation.uuid)
+                        custom_message = inbox.csat_config&.dig('message')
+                        custom_message.present? ? "#{custom_message} #{survey_link}" : I18n.t('conversations.survey.response', link: survey_link)
+                      else
+                        content
+                      end
 
-    survey_link = survey_url(conversation.uuid)
-    custom_message = inbox.csat_config&.dig('message')
-
-    custom_message.present? ? "#{custom_message} #{survey_link}" : I18n.t('conversations.survey.response', link: survey_link)
+    Messages::MarkdownRendererService.new(
+      content_to_send,
+      conversation.inbox.channel_type,
+      conversation.inbox.channel
+    ).render
   end
 
   private
diff --git a/app/services/llm_formatter/conversation_llm_formatter.rb b/app/services/llm_formatter/conversation_llm_formatter.rb
index 4e0bd7013..38d7c9e26 100644
--- a/app/services/llm_formatter/conversation_llm_formatter.rb
+++ b/app/services/llm_formatter/conversation_llm_formatter.rb
@@ -48,7 +48,7 @@ class LlmFormatter::ConversationLlmFormatter < LlmFormatter::DefaultLlmFormatter
                'Bot'
              end
     sender = "[Private Note] #{sender}" if message.private?
-    "#{sender}: #{message.content}\n"
+    "#{sender}: #{message.content_for_llm}\n"
   end
 
   def build_attributes
diff --git a/app/services/message_templates/template/out_of_office.rb b/app/services/message_templates/template/out_of_office.rb
index b6fd1b7a1..f3c8c24fa 100644
--- a/app/services/message_templates/template/out_of_office.rb
+++ b/app/services/message_templates/template/out_of_office.rb
@@ -1,6 +1,14 @@
 class MessageTemplates::Template::OutOfOffice
   pattr_initialize [:conversation!]
 
+  def self.perform_if_applicable(conversation)
+    inbox = conversation.inbox
+    return unless inbox.out_of_office?
+    return if inbox.out_of_office_message.blank?
+
+    new(conversation: conversation).perform
+  end
+
   def perform
     ActiveRecord::Base.transaction do
       conversation.messages.create!(out_of_office_message_params)
diff --git a/app/services/messages/markdown_renderer_service.rb b/app/services/messages/markdown_renderer_service.rb
new file mode 100644
index 000000000..00a731a6d
--- /dev/null
+++ b/app/services/messages/markdown_renderer_service.rb
@@ -0,0 +1,113 @@
+class Messages::MarkdownRendererService
+  CHANNEL_RENDERERS = {
+    'Channel::Email' => :render_html,
+    'Channel::WebWidget' => :render_html,
+    'Channel::Telegram' => :render_telegram_html,
+    'Channel::Whatsapp' => :render_whatsapp,
+    'Channel::FacebookPage' => :render_instagram,
+    'Channel::Instagram' => :render_instagram,
+    'Channel::Line' => :render_line,
+    'Channel::TwitterProfile' => :render_plain_text,
+    'Channel::Sms' => :render_plain_text,
+    'Channel::TwilioSms' => :render_plain_text
+  }.freeze
+
+  def initialize(content, channel_type, channel = nil)
+    @content = content
+    @channel_type = channel_type
+    @channel = channel
+  end
+
+  def render
+    return @content if @content.blank?
+
+    renderer_method = CHANNEL_RENDERERS[effective_channel_type]
+    renderer_method ? send(renderer_method) : @content
+  end
+
+  private
+
+  def effective_channel_type
+    # For Twilio SMS channel, check if it's actually WhatsApp
+    if @channel_type == 'Channel::TwilioSms' && @channel&.whatsapp?
+      'Channel::Whatsapp'
+    else
+      @channel_type
+    end
+  end
+
+  def commonmarker_doc
+    @commonmarker_doc ||= CommonMarker.render_doc(@content, [:DEFAULT, :STRIKETHROUGH_DOUBLE_TILDE])
+  end
+
+  def render_html
+    markdown_renderer = BaseMarkdownRenderer.new
+    doc = CommonMarker.render_doc(@content, :DEFAULT, [:strikethrough])
+    markdown_renderer.render(doc)
+  end
+
+  def render_telegram_html
+    # Strip whitespace from whitespace-only lines to normalize newlines
+    normalized_content = @content.gsub(/^[ \t]+$/m, '')
+    content_with_preserved_newlines = preserve_multiple_newlines(normalized_content)
+    renderer = Messages::MarkdownRenderers::TelegramRenderer.new
+    doc = CommonMarker.render_doc(content_with_preserved_newlines, [:STRIKETHROUGH_DOUBLE_TILDE], [:strikethrough])
+    result = renderer.render(doc).gsub(/\n+\z/, '')
+    restore_multiple_newlines(result)
+  end
+
+  def render_whatsapp
+    # Strip whitespace from whitespace-only lines to normalize newlines
+    normalized_content = @content.gsub(/^[ \t]+$/m, '')
+    content_with_preserved_newlines = preserve_multiple_newlines(normalized_content)
+    renderer = Messages::MarkdownRenderers::WhatsAppRenderer.new
+    doc = CommonMarker.render_doc(content_with_preserved_newlines, [:DEFAULT, :STRIKETHROUGH_DOUBLE_TILDE])
+    result = renderer.render(doc).gsub(/\n+\z/, '')
+    restore_multiple_newlines(result)
+  end
+
+  def render_instagram
+    # Strip whitespace from whitespace-only lines to normalize newlines
+    normalized_content = @content.gsub(/^[ \t]+$/m, '')
+    content_with_preserved_newlines = preserve_multiple_newlines(normalized_content)
+    renderer = Messages::MarkdownRenderers::InstagramRenderer.new
+    doc = CommonMarker.render_doc(content_with_preserved_newlines, [:DEFAULT, :STRIKETHROUGH_DOUBLE_TILDE])
+    result = renderer.render(doc).gsub(/\n+\z/, '')
+    restore_multiple_newlines(result)
+  end
+
+  def render_line
+    # Strip whitespace from whitespace-only lines to normalize newlines
+    normalized_content = @content.gsub(/^[ \t]+$/m, '')
+    content_with_preserved_newlines = preserve_multiple_newlines(normalized_content)
+    renderer = Messages::MarkdownRenderers::LineRenderer.new
+    doc = CommonMarker.render_doc(content_with_preserved_newlines, [:DEFAULT, :STRIKETHROUGH_DOUBLE_TILDE])
+    result = renderer.render(doc).gsub(/\n+\z/, '')
+    restore_multiple_newlines(result)
+  end
+
+  def render_plain_text
+    # Strip whitespace from whitespace-only lines to normalize newlines
+    normalized_content = @content.gsub(/^[ \t]+$/m, '')
+    content_with_preserved_newlines = preserve_multiple_newlines(normalized_content)
+    renderer = Messages::MarkdownRenderers::PlainTextRenderer.new
+    doc = CommonMarker.render_doc(content_with_preserved_newlines, [:DEFAULT, :STRIKETHROUGH_DOUBLE_TILDE])
+    result = renderer.render(doc).gsub(/\n+\z/, '')
+    restore_multiple_newlines(result)
+  end
+
+  # Preserve multiple consecutive newlines (2+) by replacing them with placeholders
+  # Standard markdown treats 2 newlines as paragraph break which collapses to 1 newline, we preserve 2+
+  def preserve_multiple_newlines(content)
+    content.gsub(/\n{2,}/) do |match|
+      "{{PRESERVE_#{match.length}_NEWLINES}}"
+    end
+  end
+
+  # Restore multiple newlines from placeholders
+  def restore_multiple_newlines(content)
+    content.gsub(/\{\{PRESERVE_(\d+)_NEWLINES\}\}/) do |_match|
+      "\n" * Regexp.last_match(1).to_i
+    end
+  end
+end
diff --git a/app/services/messages/markdown_renderers/base_markdown_renderer.rb b/app/services/messages/markdown_renderers/base_markdown_renderer.rb
new file mode 100644
index 000000000..e2634f2d3
--- /dev/null
+++ b/app/services/messages/markdown_renderers/base_markdown_renderer.rb
@@ -0,0 +1,39 @@
+class Messages::MarkdownRenderers::BaseMarkdownRenderer < CommonMarker::Renderer
+  def document(_node)
+    out(:children)
+  end
+
+  def paragraph(_node)
+    out(:children)
+    cr
+  end
+
+  def text(node)
+    out(node.string_content)
+  end
+
+  def softbreak(_node)
+    out(' ')
+  end
+
+  def linebreak(_node)
+    out("\n")
+  end
+
+  def strikethrough(_node)
+    out('<del>')
+    out(:children)
+    out('</del>')
+  end
+
+  def method_missing(method_name, node = nil, *args, **kwargs, &)
+    return super unless node.is_a?(CommonMarker::Node)
+
+    out(:children)
+    cr unless %i[text softbreak linebreak].include?(node.type)
+  end
+
+  def respond_to_missing?(_method_name, _include_private = false)
+    true
+  end
+end
diff --git a/app/services/messages/markdown_renderers/instagram_renderer.rb b/app/services/messages/markdown_renderers/instagram_renderer.rb
new file mode 100644
index 000000000..3b47577b2
--- /dev/null
+++ b/app/services/messages/markdown_renderers/instagram_renderer.rb
@@ -0,0 +1,48 @@
+class Messages::MarkdownRenderers::InstagramRenderer < Messages::MarkdownRenderers::BaseMarkdownRenderer
+  def initialize
+    super
+    @list_item_number = 0
+  end
+
+  def strong(_node)
+    out('*', :children, '*')
+  end
+
+  def emph(_node)
+    out('_', :children, '_')
+  end
+
+  def code(node)
+    out(node.string_content)
+  end
+
+  def link(node)
+    out(node.url)
+  end
+
+  def list(node)
+    @list_type = node.list_type
+    @list_item_number = @list_type == :ordered_list ? node.list_start : 0
+    out(:children)
+    cr
+  end
+
+  def list_item(_node)
+    if @list_type == :ordered_list
+      out("#{@list_item_number}. ", :children)
+      @list_item_number += 1
+    else
+      out('- ', :children)
+    end
+    cr
+  end
+
+  def blockquote(_node)
+    out(:children)
+    cr
+  end
+
+  def softbreak(_node)
+    out("\n")
+  end
+end
diff --git a/app/services/messages/markdown_renderers/line_renderer.rb b/app/services/messages/markdown_renderers/line_renderer.rb
new file mode 100644
index 000000000..f47c21120
--- /dev/null
+++ b/app/services/messages/markdown_renderers/line_renderer.rb
@@ -0,0 +1,36 @@
+class Messages::MarkdownRenderers::LineRenderer < Messages::MarkdownRenderers::BaseMarkdownRenderer
+  def strong(_node)
+    out(' *', :children, '* ')
+  end
+
+  def emph(_node)
+    out(' _', :children, '_ ')
+  end
+
+  def code(node)
+    out(' `', node.string_content, '` ')
+  end
+
+  def link(node)
+    out(node.url)
+  end
+
+  def list(_node)
+    out(:children)
+    cr
+  end
+
+  def list_item(_node)
+    out(:children)
+    cr
+  end
+
+  def code_block(node)
+    out(' ```', "\n", node.string_content, '``` ', "\n")
+  end
+
+  def blockquote(_node)
+    out(:children)
+    cr
+  end
+end
diff --git a/app/services/messages/markdown_renderers/plain_text_renderer.rb b/app/services/messages/markdown_renderers/plain_text_renderer.rb
new file mode 100644
index 000000000..403d3a236
--- /dev/null
+++ b/app/services/messages/markdown_renderers/plain_text_renderer.rb
@@ -0,0 +1,62 @@
+class Messages::MarkdownRenderers::PlainTextRenderer < Messages::MarkdownRenderers::BaseMarkdownRenderer
+  def initialize
+    super
+    @list_item_number = 0
+  end
+
+  def link(node)
+    out(:children)
+    out(' ', node.url) if node.url.present?
+  end
+
+  def strong(_node)
+    out(:children)
+  end
+
+  def emph(_node)
+    out(:children)
+  end
+
+  def code(node)
+    out(node.string_content)
+  end
+
+  def list(node)
+    @list_type = node.list_type
+    @list_item_number = @list_type == :ordered_list ? node.list_start : 0
+    out(:children)
+    cr
+  end
+
+  def list_item(_node)
+    if @list_type == :ordered_list
+      out("#{@list_item_number}. ", :children)
+      @list_item_number += 1
+    else
+      out('- ', :children)
+    end
+    cr
+  end
+
+  def blockquote(_node)
+    out(:children)
+    cr
+  end
+
+  def code_block(node)
+    out(node.string_content, "\n")
+  end
+
+  def header(_node)
+    out(:children)
+    cr
+  end
+
+  def thematic_break(_node)
+    out("\n")
+  end
+
+  def softbreak(_node)
+    out("\n")
+  end
+end
diff --git a/app/services/messages/markdown_renderers/telegram_renderer.rb b/app/services/messages/markdown_renderers/telegram_renderer.rb
new file mode 100644
index 000000000..5252b57c6
--- /dev/null
+++ b/app/services/messages/markdown_renderers/telegram_renderer.rb
@@ -0,0 +1,60 @@
+class Messages::MarkdownRenderers::TelegramRenderer < Messages::MarkdownRenderers::BaseMarkdownRenderer
+  def initialize
+    super
+    @list_item_number = 0
+  end
+
+  def strong(_node)
+    out('<strong>', :children, '</strong>')
+  end
+
+  def emph(_node)
+    out('<em>', :children, '</em>')
+  end
+
+  def code(node)
+    out('<code>', node.string_content, '</code>')
+  end
+
+  def link(node)
+    out('<a href="', node.url, '">', :children, '</a>')
+  end
+
+  def strikethrough(_node)
+    out('<del>', :children, '</del>')
+  end
+
+  def blockquote(_node)
+    out('<blockquote>', :children, '</blockquote>')
+  end
+
+  def code_block(node)
+    out('<pre>', node.string_content, '</pre>')
+  end
+
+  def list(node)
+    @list_type = node.list_type
+    @list_item_number = @list_type == :ordered_list ? node.list_start : 0
+    out(:children)
+    cr
+  end
+
+  def list_item(_node)
+    if @list_type == :ordered_list
+      out("#{@list_item_number}. ", :children)
+      @list_item_number += 1
+    else
+      out('• ', :children)
+    end
+    cr
+  end
+
+  def header(_node)
+    out('<strong>', :children, '</strong>')
+    cr
+  end
+
+  def softbreak(_node)
+    out("\n")
+  end
+end
diff --git a/app/services/messages/markdown_renderers/whats_app_renderer.rb b/app/services/messages/markdown_renderers/whats_app_renderer.rb
new file mode 100644
index 000000000..9f7dbab6e
--- /dev/null
+++ b/app/services/messages/markdown_renderers/whats_app_renderer.rb
@@ -0,0 +1,36 @@
+class Messages::MarkdownRenderers::WhatsAppRenderer < Messages::MarkdownRenderers::BaseMarkdownRenderer
+  def strong(_node)
+    out('*', :children, '*')
+  end
+
+  def emph(_node)
+    out('_', :children, '_')
+  end
+
+  def code(node)
+    out('`', node.string_content, '`')
+  end
+
+  def link(node)
+    out(node.url)
+  end
+
+  def list(_node)
+    out(:children)
+    cr
+  end
+
+  def list_item(_node)
+    out('- ', :children)
+    cr
+  end
+
+  def blockquote(_node)
+    out('> ', :children)
+    cr
+  end
+
+  def softbreak(_node)
+    out("\n")
+  end
+end
diff --git a/app/services/whatsapp/csat_template_name_service.rb b/app/services/whatsapp/csat_template_name_service.rb
new file mode 100644
index 000000000..223efda04
--- /dev/null
+++ b/app/services/whatsapp/csat_template_name_service.rb
@@ -0,0 +1,49 @@
+class Whatsapp::CsatTemplateNameService
+  CSAT_BASE_NAME = 'customer_satisfaction_survey'.freeze
+
+  # Generates template names like: customer_satisfaction_survey_{inbox_id}_{version_number}
+
+  def self.csat_template_name(inbox_id, version = nil)
+    base_name = csat_base_name_for_inbox(inbox_id)
+    version ? "#{base_name}_#{version}" : base_name
+  end
+
+  def self.extract_version(template_name, inbox_id)
+    return nil if template_name.blank?
+
+    pattern = versioned_pattern_for_inbox(inbox_id)
+    match = template_name.match(pattern)
+    match ? match[1].to_i : nil
+  end
+
+  def self.generate_next_template_name(base_name, inbox_id, current_template_name)
+    return base_name if current_template_name.blank?
+
+    current_version = extract_version(current_template_name, inbox_id)
+    next_version = current_version ? current_version + 1 : 1
+    csat_template_name(inbox_id, next_version)
+  end
+
+  def self.matches_csat_pattern?(template_name, inbox_id)
+    return false if template_name.blank?
+
+    base_pattern = base_pattern_for_inbox(inbox_id)
+    versioned_pattern = versioned_pattern_for_inbox(inbox_id)
+
+    template_name.match?(base_pattern) || template_name.match?(versioned_pattern)
+  end
+
+  def self.csat_base_name_for_inbox(inbox_id)
+    "#{CSAT_BASE_NAME}_#{inbox_id}"
+  end
+
+  def self.base_pattern_for_inbox(inbox_id)
+    /^#{CSAT_BASE_NAME}_#{inbox_id}$/
+  end
+
+  def self.versioned_pattern_for_inbox(inbox_id)
+    /^#{CSAT_BASE_NAME}_#{inbox_id}_(\d+)$/
+  end
+
+  private_class_method :csat_base_name_for_inbox, :base_pattern_for_inbox, :versioned_pattern_for_inbox
+end
diff --git a/app/services/whatsapp/csat_template_service.rb b/app/services/whatsapp/csat_template_service.rb
new file mode 100644
index 000000000..43009b484
--- /dev/null
+++ b/app/services/whatsapp/csat_template_service.rb
@@ -0,0 +1,139 @@
+class Whatsapp::CsatTemplateService
+  DEFAULT_BUTTON_TEXT = 'Please rate us'.freeze
+  DEFAULT_LANGUAGE = 'en'.freeze
+  WHATSAPP_API_VERSION = 'v14.0'.freeze
+  TEMPLATE_CATEGORY = 'MARKETING'.freeze
+  TEMPLATE_STATUS_PENDING = 'PENDING'.freeze
+
+  def initialize(whatsapp_channel)
+    @whatsapp_channel = whatsapp_channel
+  end
+
+  def create_template(template_config)
+    base_name = template_config[:template_name]
+    template_name = generate_template_name(base_name)
+    template_config_with_name = template_config.merge(template_name: template_name)
+    request_body = build_template_request_body(template_config_with_name)
+    response = send_template_creation_request(request_body)
+    process_template_creation_response(response, template_config_with_name)
+  end
+
+  def delete_template(template_name = nil)
+    template_name ||= Whatsapp::CsatTemplateNameService.csat_template_name(@whatsapp_channel.inbox.id)
+    response = HTTParty.delete(
+      "#{business_account_path}/message_templates?name=#{template_name}",
+      headers: api_headers
+    )
+    { success: response.success?, response_body: response.body }
+  end
+
+  def get_template_status(template_name)
+    response = HTTParty.get("#{business_account_path}/message_templates?name=#{template_name}", headers: api_headers)
+
+    if response.success? && response['data']&.any?
+      template_data = response['data'].first
+      {
+        success: true,
+        template: {
+          id: template_data['id'], name: template_data['name'],
+          status: template_data['status'], language: template_data['language']
+        }
+      }
+    else
+      { success: false, error: 'Template not found' }
+    end
+  rescue StandardError => e
+    Rails.logger.error "Error fetching template status: #{e.message}"
+    { success: false, error: e.message }
+  end
+
+  private
+
+  def generate_template_name(base_name)
+    current_template_name = current_template_name_from_config
+    Whatsapp::CsatTemplateNameService.generate_next_template_name(base_name, @whatsapp_channel.inbox.id, current_template_name)
+  end
+
+  def current_template_name_from_config
+    @whatsapp_channel.inbox.csat_config&.dig('template', 'name')
+  end
+
+  def build_template_request_body(template_config)
+    {
+      name: template_config[:template_name],
+      language: template_config[:language] || DEFAULT_LANGUAGE,
+      category: TEMPLATE_CATEGORY,
+      components: build_template_components(template_config)
+    }
+  end
+
+  def build_template_components(template_config)
+    [
+      build_body_component(template_config[:message]),
+      build_buttons_component(template_config)
+    ]
+  end
+
+  def build_body_component(message)
+    {
+      type: 'BODY',
+      text: message
+    }
+  end
+
+  def build_buttons_component(template_config)
+    {
+      type: 'BUTTONS',
+      buttons: [
+        {
+          type: 'URL',
+          text: template_config[:button_text] || DEFAULT_BUTTON_TEXT,
+          url: "#{template_config[:base_url]}/survey/responses/{{1}}",
+          example: ['12345']
+        }
+      ]
+    }
+  end
+
+  def send_template_creation_request(request_body)
+    HTTParty.post(
+      "#{business_account_path}/message_templates",
+      headers: api_headers,
+      body: request_body.to_json
+    )
+  end
+
+  def process_template_creation_response(response, template_config = {})
+    if response.success?
+      {
+        success: true,
+        template_id: response['id'],
+        template_name: response['name'] || template_config[:template_name],
+        language: template_config[:language] || DEFAULT_LANGUAGE,
+        status: TEMPLATE_STATUS_PENDING
+      }
+    else
+      Rails.logger.error "WhatsApp template creation failed: #{response.code} - #{response.body}"
+      {
+        success: false,
+        error: 'Template creation failed',
+        response_body: response.body
+      }
+    end
+  end
+
+  def business_account_path
+    "#{api_base_path}/#{WHATSAPP_API_VERSION}/#{@whatsapp_channel.provider_config['business_account_id']}"
+  end
+
+  def api_headers
+    {
+      'Authorization' => "Bearer #{@whatsapp_channel.provider_config['api_key']}",
+      'Content-Type' => 'application/json'
+    }
+  end
+
+  def api_base_path
+    ENV.fetch('WHATSAPP_CLOUD_BASE_URL', 'https://graph.facebook.com')
+  end
+end
diff --git a/app/services/whatsapp/providers/whatsapp_cloud_service.rb b/app/services/whatsapp/providers/whatsapp_cloud_service.rb
index 1968693ff..e13ee8979 100644
--- a/app/services/whatsapp/providers/whatsapp_cloud_service.rb
+++ b/app/services/whatsapp/providers/whatsapp_cloud_service.rb
@@ -62,12 +62,31 @@ class Whatsapp::Providers::WhatsappCloudService < Whatsapp::Providers::BaseServi
     { 'Authorization' => "Bearer #{whatsapp_channel.provider_config['api_key']}", 'Content-Type' => 'application/json' }
   end
 
+  def create_csat_template(template_config)
+    csat_template_service.create_template(template_config)
+  end
+
+  def delete_csat_template(template_name = nil)
+    template_name ||= Whatsapp::CsatTemplateNameService.csat_template_name(whatsapp_channel.inbox.id)
+    csat_template_service.delete_template(template_name)
+  end
+
+  def get_template_status(template_name)
+    csat_template_service.get_template_status(template_name)
+  end
+
   def media_url(media_id, phone_number_id = nil)
     url = "#{api_base_path}/v13.0/#{media_id}"
     url += "?phone_number_id=#{phone_number_id}" if phone_number_id
     url
   end
 
+  private
+
+  def csat_template_service
+    @csat_template_service ||= Whatsapp::CsatTemplateService.new(whatsapp_channel)
+  end
+
   def api_base_path
     ENV.fetch('WHATSAPP_CLOUD_BASE_URL', 'https://graph.facebook.com')
   end
diff --git a/app/views/mailers/conversation_reply_mailer/email_reply.html.erb b/app/views/mailers/conversation_reply_mailer/email_reply.html.erb
index f5f827e4c..aae8d3c5f 100644
--- a/app/views/mailers/conversation_reply_mailer/email_reply.html.erb
+++ b/app/views/mailers/conversation_reply_mailer/email_reply.html.erb
@@ -1,7 +1,7 @@
 <% if @message.content_attributes.dig('email', 'html_content', 'reply').present? %>
 <%= @message.content_attributes.dig('email', 'html_content', 'reply').html_safe %>
 <% elsif @message.content %>
-<%= ChatwootMarkdownRenderer.new(@message.outgoing_content).render_message %>
+<%= @message.outgoing_content.html_safe %>
 <% end %>
 <% if @large_attachments.present? %>
 <p>Attachments:</p>
diff --git a/config/initializers/ai_agents.rb b/config/initializers/ai_agents.rb
index 37bdd589f..be8a8a9cc 100644
--- a/config/initializers/ai_agents.rb
+++ b/config/initializers/ai_agents.rb
@@ -4,8 +4,8 @@ require 'agents'
 
 Rails.application.config.after_initialize do
   api_key = InstallationConfig.find_by(name: 'CAPTAIN_OPEN_AI_API_KEY')&.value
-  model = InstallationConfig.find_by(name: 'CAPTAIN_OPEN_AI_MODEL')&.value.presence || OpenAiConstants::DEFAULT_MODEL
-  api_endpoint = InstallationConfig.find_by(name: 'CAPTAIN_OPEN_AI_ENDPOINT')&.value || OpenAiConstants::DEFAULT_ENDPOINT
+  model = InstallationConfig.find_by(name: 'CAPTAIN_OPEN_AI_MODEL')&.value.presence || LlmConstants::DEFAULT_MODEL
+  api_endpoint = InstallationConfig.find_by(name: 'CAPTAIN_OPEN_AI_ENDPOINT')&.value || LlmConstants::OPENAI_API_ENDPOINT
 
   if api_key.present?
     Agents.configure do |config|
diff --git a/config/routes.rb b/config/routes.rb
index 9b22cb333..0ac001612 100644
--- a/config/routes.rb
+++ b/config/routes.rb
@@ -203,6 +203,8 @@ Rails.application.routes.draw do
             delete :avatar, on: :member
             post :sync_templates, on: :member
             get :health, on: :member
+
+            resource :csat_template, only: [:show, :create], controller: 'inbox_csat_templates'
           end
           resources :inbox_members, only: [:create, :show], param: :inbox_id do
             collection do
diff --git a/enterprise/app/controllers/api/v1/accounts/sla_policies_controller.rb b/enterprise/app/controllers/api/v1/accounts/sla_policies_controller.rb
index ec879b042..b3b0f52d4 100644
--- a/enterprise/app/controllers/api/v1/accounts/sla_policies_controller.rb
+++ b/enterprise/app/controllers/api/v1/accounts/sla_policies_controller.rb
@@ -17,7 +17,7 @@ class Api::V1::Accounts::SlaPoliciesController < Api::V1::Accounts::EnterpriseAc
   end
 
   def destroy
-    @sla_policy.destroy!
+    ::DeleteObjectJob.perform_later(@sla_policy, Current.user, request.ip) if @sla_policy.present?
     head :ok
   end
 
diff --git a/enterprise/app/controllers/enterprise/public/api/v1/portals/articles_controller.rb b/enterprise/app/controllers/enterprise/public/api/v1/portals/articles_controller.rb
index 240da0dca..77162dad0 100644
--- a/enterprise/app/controllers/enterprise/public/api/v1/portals/articles_controller.rb
+++ b/enterprise/app/controllers/enterprise/public/api/v1/portals/articles_controller.rb
@@ -3,7 +3,7 @@ module Enterprise::Public::Api::V1::Portals::ArticlesController
 
   def search_articles
     if @portal.account.feature_enabled?('help_center_embedding_search')
-      @articles = @articles.vector_search(list_params) if list_params[:query].present?
+      @articles = @articles.vector_search(list_params.merge(account_id: @portal.account_id)) if list_params[:query].present?
     else
       super
     end
diff --git a/enterprise/app/helpers/captain/chat_helper.rb b/enterprise/app/helpers/captain/chat_helper.rb
index a60e3015f..9bbbd86a5 100644
--- a/enterprise/app/helpers/captain/chat_helper.rb
+++ b/enterprise/app/helpers/captain/chat_helper.rb
@@ -21,20 +21,18 @@ module Captain::ChatHelper
 
   def build_chat
     llm_chat = chat(model: @model, temperature: temperature)
-    llm_chat.with_params(response_format: { type: 'json_object' })
+    llm_chat = llm_chat.with_params(response_format: { type: 'json_object' })
 
     llm_chat = setup_tools(llm_chat)
-    setup_system_instructions(llm_chat)
+    llm_chat = setup_system_instructions(llm_chat)
     setup_event_handlers(llm_chat)
-
-    llm_chat
   end
 
-  def setup_tools(chat)
+  def setup_tools(llm_chat)
     @tools&.each do |tool|
-      chat.with_tool(tool)
+      llm_chat = llm_chat.with_tool(tool)
     end
-    chat
+    llm_chat
   end
 
   def setup_system_instructions(chat)
diff --git a/enterprise/app/jobs/captain/conversation/response_builder_job.rb b/enterprise/app/jobs/captain/conversation/response_builder_job.rb
index f218ff68c..9f8acc474 100644
--- a/enterprise/app/jobs/captain/conversation/response_builder_job.rb
+++ b/enterprise/app/jobs/captain/conversation/response_builder_job.rb
@@ -87,10 +87,15 @@ class Captain::Conversation::ResponseBuilderJob < ApplicationJob
       I18n.with_locale(@assistant.account.locale) do
         create_handoff_message
         @conversation.bot_handoff!
+        send_out_of_office_message_if_applicable
       end
     end
   end
 
+  def send_out_of_office_message_if_applicable
+    ::MessageTemplates::Template::OutOfOffice.perform_if_applicable(@conversation)
+  end
+
   def create_handoff_message
     create_outgoing_message(
       @assistant.config['handoff_message'].presence || I18n.t('conversations.captain.handoff')
diff --git a/enterprise/app/jobs/captain/documents/response_builder_job.rb b/enterprise/app/jobs/captain/documents/response_builder_job.rb
index b22fa5bc1..553cec110 100644
--- a/enterprise/app/jobs/captain/documents/response_builder_job.rb
+++ b/enterprise/app/jobs/captain/documents/response_builder_job.rb
@@ -26,7 +26,7 @@ class Captain::Documents::ResponseBuilderJob < ApplicationJob
   end
 
   def generate_standard_faqs(document)
-    Captain::Llm::FaqGeneratorService.new(document.content, document.account.locale_english_name).generate
+    Captain::Llm::FaqGeneratorService.new(document.content, document.account.locale_english_name, account_id: document.account_id).generate
   end
 
   def build_paginated_service(document, options)
diff --git a/enterprise/app/jobs/captain/llm/update_embedding_job.rb b/enterprise/app/jobs/captain/llm/update_embedding_job.rb
index 20d10f8f5..72ab540bd 100644
--- a/enterprise/app/jobs/captain/llm/update_embedding_job.rb
+++ b/enterprise/app/jobs/captain/llm/update_embedding_job.rb
@@ -2,7 +2,8 @@ class Captain::Llm::UpdateEmbeddingJob < ApplicationJob
   queue_as :low
 
   def perform(record, content)
-    embedding = Captain::Llm::EmbeddingService.new.get_embedding(content)
+    account_id = record.account_id
+    embedding = Captain::Llm::EmbeddingService.new(account_id: account_id).get_embedding(content)
     record.update!(embedding: embedding)
   end
 end
diff --git a/enterprise/app/jobs/enterprise/delete_object_job.rb b/enterprise/app/jobs/enterprise/delete_object_job.rb
index 147fa0d43..375015bc7 100644
--- a/enterprise/app/jobs/enterprise/delete_object_job.rb
+++ b/enterprise/app/jobs/enterprise/delete_object_job.rb
@@ -1,10 +1,18 @@
 module Enterprise::DeleteObjectJob
+  private
+
+  def heavy_associations
+    super.merge(
+      SlaPolicy => %i[applied_slas]
+    ).freeze
+  end
+
   def process_post_deletion_tasks(object, user, ip)
     create_audit_entry(object, user, ip)
   end
 
   def create_audit_entry(object, user, ip)
-    return unless %w[Inbox Conversation].include?(object.class.to_s) && user.present?
+    return unless %w[Inbox Conversation SlaPolicy].include?(object.class.to_s) && user.present?
 
     Enterprise::AuditLog.create(
       auditable: object,
diff --git a/enterprise/app/models/article_embedding.rb b/enterprise/app/models/article_embedding.rb
index 14665a24b..4dafcfe06 100644
--- a/enterprise/app/models/article_embedding.rb
+++ b/enterprise/app/models/article_embedding.rb
@@ -19,6 +19,8 @@ class ArticleEmbedding < ApplicationRecord
 
   after_commit :update_response_embedding
 
+  delegate :account_id, to: :article
+
   private
 
   def update_response_embedding
diff --git a/enterprise/app/models/captain/assistant_response.rb b/enterprise/app/models/captain/assistant_response.rb
index 7ab2878a3..12dcab1cc 100644
--- a/enterprise/app/models/captain/assistant_response.rb
+++ b/enterprise/app/models/captain/assistant_response.rb
@@ -44,8 +44,8 @@ class Captain::AssistantResponse < ApplicationRecord
 
   enum status: { pending: 0, approved: 1 }
 
-  def self.search(query)
-    embedding = Captain::Llm::EmbeddingService.new.get_embedding(query)
+  def self.search(query, account_id: nil)
+    embedding = Captain::Llm::EmbeddingService.new(account_id: account_id).get_embedding(query)
     nearest_neighbors(:embedding, embedding, distance: 'cosine').limit(5)
   end
 
diff --git a/enterprise/app/models/concerns/agentable.rb b/enterprise/app/models/concerns/agentable.rb
index dab76a726..e5b0b8eef 100644
--- a/enterprise/app/models/concerns/agentable.rb
+++ b/enterprise/app/models/concerns/agentable.rb
@@ -43,7 +43,7 @@ module Concerns::Agentable
   end
 
   def agent_model
-    InstallationConfig.find_by(name: 'CAPTAIN_OPEN_AI_MODEL')&.value.presence || OpenAiConstants::DEFAULT_MODEL
+    InstallationConfig.find_by(name: 'CAPTAIN_OPEN_AI_MODEL')&.value.presence || LlmConstants::DEFAULT_MODEL
   end
 
   def agent_response_schema
diff --git a/enterprise/app/models/concerns/toolable.rb b/enterprise/app/models/concerns/toolable.rb
index ad047e8f8..51ec1be3e 100644
--- a/enterprise/app/models/concerns/toolable.rb
+++ b/enterprise/app/models/concerns/toolable.rb
@@ -66,6 +66,31 @@ module Concerns::Toolable
     [auth_config['username'], auth_config['password']]
   end
 
+  def build_metadata_headers(state)
+    {}.tap do |headers|
+      add_base_headers(headers, state)
+      add_conversation_headers(headers, state[:conversation]) if state[:conversation]
+      add_contact_headers(headers, state[:contact]) if state[:contact]
+    end
+  end
+
+  def add_base_headers(headers, state)
+    headers['X-Chatwoot-Account-Id'] = state[:account_id].to_s if state[:account_id]
+    headers['X-Chatwoot-Assistant-Id'] = state[:assistant_id].to_s if state[:assistant_id]
+    headers['X-Chatwoot-Tool-Slug'] = slug if slug.present?
+  end
+
+  def add_conversation_headers(headers, conversation)
+    headers['X-Chatwoot-Conversation-Id'] = conversation[:id].to_s if conversation[:id]
+    headers['X-Chatwoot-Conversation-Display-Id'] = conversation[:display_id].to_s if conversation[:display_id]
+  end
+
+  def add_contact_headers(headers, contact)
+    headers['X-Chatwoot-Contact-Id'] = contact[:id].to_s if contact[:id]
+    headers['X-Chatwoot-Contact-Email'] = contact[:email].to_s if contact[:email].present?
+    headers['X-Chatwoot-Contact-Phone'] = contact[:phone_number].to_s if contact[:phone_number].present?
+  end
+
   def format_response(raw_response_body)
     return raw_response_body if response_template.blank?
 
diff --git a/enterprise/app/models/enterprise/concerns/article.rb b/enterprise/app/models/enterprise/concerns/article.rb
index d3a94d7b7..4527bfdf6 100644
--- a/enterprise/app/models/enterprise/concerns/article.rb
+++ b/enterprise/app/models/enterprise/concerns/article.rb
@@ -11,7 +11,7 @@ module Enterprise::Concerns::Article
     add_article_embedding_association
 
     def self.vector_search(params)
-      embedding = Captain::Llm::EmbeddingService.new.get_embedding(params['query'])
+      embedding = Captain::Llm::EmbeddingService.new(account_id: params[:account_id]).get_embedding(params['query'])
       records = joins(
         :category
       ).search_by_category_slug(
diff --git a/enterprise/app/models/sla_policy.rb b/enterprise/app/models/sla_policy.rb
index f53f00ed5..f61d5a1f3 100644
--- a/enterprise/app/models/sla_policy.rb
+++ b/enterprise/app/models/sla_policy.rb
@@ -22,7 +22,7 @@ class SlaPolicy < ApplicationRecord
   validates :name, presence: true
 
   has_many :conversations, dependent: :nullify
-  has_many :applied_slas, dependent: :destroy
+  has_many :applied_slas, dependent: :destroy_async
 
   def push_event_data
     {
diff --git a/enterprise/app/services/captain/llm/contact_attributes_service.rb b/enterprise/app/services/captain/llm/contact_attributes_service.rb
index f2c48de57..803c06f09 100644
--- a/enterprise/app/services/captain/llm/contact_attributes_service.rb
+++ b/enterprise/app/services/captain/llm/contact_attributes_service.rb
@@ -1,4 +1,5 @@
-class Captain::Llm::ContactAttributesService < Llm::LegacyBaseOpenAiService
+class Captain::Llm::ContactAttributesService < Llm::BaseAiService
+  include Integrations::LlmInstrumentation
   def initialize(assistant, conversation)
     super()
     @assistant = assistant
@@ -17,33 +18,38 @@ class Captain::Llm::ContactAttributesService < Llm::LegacyBaseOpenAiService
   attr_reader :content
 
   def generate_attributes
-    response = @client.chat(parameters: chat_parameters)
-    parse_response(response)
-  rescue OpenAI::Error => e
-    Rails.logger.error "OpenAI API Error: #{e.message}"
+    response = instrument_llm_call(instrumentation_params) do
+      chat
+        .with_params(response_format: { type: 'json_object' })
+        .with_instructions(system_prompt)
+        .ask(@content)
+    end
+    parse_response(response.content)
+  rescue RubyLLM::Error => e
+    ChatwootExceptionTracker.new(e, account: @conversation.account).capture_exception
     []
   end
 
-  def chat_parameters
-    prompt = Captain::Llm::SystemPromptsService.attributes_generator
+  def instrumentation_params
     {
+      span_name: 'llm.captain.contact_attributes',
       model: @model,
-      response_format: { type: 'json_object' },
+      temperature: @temperature,
+      account_id: @conversation.account_id,
+      feature_name: 'contact_attributes',
       messages: [
-        {
-          role: 'system',
-          content: prompt
-        },
-        {
-          role: 'user',
-          content: content
-        }
-      ]
+        { role: 'system', content: system_prompt },
+        { role: 'user', content: @content }
+      ],
+      metadata: { assistant_id: @assistant.id, contact_id: @contact.id }
     }
   end
 
-  def parse_response(response)
-    content = response.dig('choices', 0, 'message', 'content')
+  def system_prompt
+    Captain::Llm::SystemPromptsService.attributes_generator
+  end
+
+  def parse_response(content)
     return [] if content.nil?
 
     JSON.parse(content.strip).fetch('attributes', [])
diff --git a/enterprise/app/services/captain/llm/contact_notes_service.rb b/enterprise/app/services/captain/llm/contact_notes_service.rb
index 4ee4fcb5e..d37f9fea6 100644
--- a/enterprise/app/services/captain/llm/contact_notes_service.rb
+++ b/enterprise/app/services/captain/llm/contact_notes_service.rb
@@ -1,4 +1,5 @@
-class Captain::Llm::ContactNotesService < Llm::LegacyBaseOpenAiService
+class Captain::Llm::ContactNotesService < Llm::BaseAiService
+  include Integrations::LlmInstrumentation
   def initialize(assistant, conversation)
     super()
     @assistant = assistant
@@ -18,38 +19,42 @@ class Captain::Llm::ContactNotesService < Llm::LegacyBaseOpenAiService
   attr_reader :content
 
   def generate_notes
-    response = @client.chat(parameters: chat_parameters)
-    parse_response(response)
-  rescue OpenAI::Error => e
-    Rails.logger.error "OpenAI API Error: #{e.message}"
+    response = instrument_llm_call(instrumentation_params) do
+      chat
+        .with_params(response_format: { type: 'json_object' })
+        .with_instructions(system_prompt)
+        .ask(@content)
+    end
+    parse_response(response.content)
+  rescue RubyLLM::Error => e
+    ChatwootExceptionTracker.new(e, account: @conversation.account).capture_exception
     []
   end
 
-  def chat_parameters
-    account_language = @conversation.account.locale_english_name
-    prompt = Captain::Llm::SystemPromptsService.notes_generator(account_language)
-
+  def instrumentation_params
     {
+      span_name: 'llm.captain.contact_notes',
       model: @model,
-      response_format: { type: 'json_object' },
+      temperature: @temperature,
+      account_id: @conversation.account_id,
+      feature_name: 'contact_notes',
       messages: [
-        {
-          role: 'system',
-          content: prompt
-        },
-        {
-          role: 'user',
-          content: content
-        }
-      ]
+        { role: 'system', content: system_prompt },
+        { role: 'user', content: @content }
+      ],
+      metadata: { assistant_id: @assistant.id, contact_id: @contact.id }
     }
   end
 
-  def parse_response(response)
-    content = response.dig('choices', 0, 'message', 'content')
-    return [] if content.nil?
+  def system_prompt
+    account_language = @conversation.account.locale_english_name
+    Captain::Llm::SystemPromptsService.notes_generator(account_language)
+  end
 
-    JSON.parse(content.strip).fetch('notes', [])
+  def parse_response(response)
+    return [] if response.nil?
+
+    JSON.parse(response.strip).fetch('notes', [])
   rescue JSON::ParserError => e
     Rails.logger.error "Error in parsing GPT processed response: #{e.message}"
     []
diff --git a/enterprise/app/services/captain/llm/conversation_faq_service.rb b/enterprise/app/services/captain/llm/conversation_faq_service.rb
index 47d1433bd..e9152bc99 100644
--- a/enterprise/app/services/captain/llm/conversation_faq_service.rb
+++ b/enterprise/app/services/captain/llm/conversation_faq_service.rb
@@ -1,4 +1,5 @@
-class Captain::Llm::ConversationFaqService < Llm::LegacyBaseOpenAiService
+class Captain::Llm::ConversationFaqService < Llm::BaseAiService
+  include Integrations::LlmInstrumentation
   DISTANCE_THRESHOLD = 0.3
 
   def initialize(assistant, conversation)
@@ -35,7 +36,7 @@ class Captain::Llm::ConversationFaqService < Llm::LegacyBaseOpenAiService
 
     faqs.each do |faq|
       combined_text = "#{faq['question']}: #{faq['answer']}"
-      embedding = Captain::Llm::EmbeddingService.new.get_embedding(combined_text)
+      embedding = Captain::Llm::EmbeddingService.new(account_id: @conversation.account_id).get_embedding(combined_text)
       similar_faqs = find_similar_faqs(embedding)
 
       if similar_faqs.any?
@@ -81,38 +82,43 @@ class Captain::Llm::ConversationFaqService < Llm::LegacyBaseOpenAiService
   end
 
   def generate
-    response = @client.chat(parameters: chat_parameters)
-    parse_response(response)
-  rescue OpenAI::Error => e
-    Rails.logger.error "OpenAI API Error: #{e.message}"
+    response = instrument_llm_call(instrumentation_params) do
+      chat
+        .with_params(response_format: { type: 'json_object' })
+        .with_instructions(system_prompt)
+        .ask(@content)
+    end
+    parse_response(response.content)
+  rescue RubyLLM::Error => e
+    Rails.logger.error "LLM API Error: #{e.message}"
     []
   end
 
-  def chat_parameters
-    account_language = @conversation.account.locale_english_name
-    prompt = Captain::Llm::SystemPromptsService.conversation_faq_generator(account_language)
-
+  def instrumentation_params
     {
+      span_name: 'llm.captain.conversation_faq',
       model: @model,
-      response_format: { type: 'json_object' },
+      temperature: @temperature,
+      account_id: @conversation.account_id,
+      conversation_id: @conversation.id,
+      feature_name: 'conversation_faq',
       messages: [
-        {
-          role: 'system',
-          content: prompt
-        },
-        {
-          role: 'user',
-          content: content
-        }
-      ]
+        { role: 'system', content: system_prompt },
+        { role: 'user', content: @content }
+      ],
+      metadata: { assistant_id: @assistant.id }
     }
   end
 
-  def parse_response(response)
-    content = response.dig('choices', 0, 'message', 'content')
-    return [] if content.nil?
+  def system_prompt
+    account_language = @conversation.account.locale_english_name
+    Captain::Llm::SystemPromptsService.conversation_faq_generator(account_language)
+  end
 
-    JSON.parse(content.strip).fetch('faqs', [])
+  def parse_response(response)
+    return [] if response.nil?
+
+    JSON.parse(response.strip).fetch('faqs', [])
   rescue JSON::ParserError => e
     Rails.logger.error "Error in parsing GPT processed response: #{e.message}"
     []
diff --git a/enterprise/app/services/captain/llm/embedding_service.rb b/enterprise/app/services/captain/llm/embedding_service.rb
index 5190ed28a..2fac54594 100644
--- a/enterprise/app/services/captain/llm/embedding_service.rb
+++ b/enterprise/app/services/captain/llm/embedding_service.rb
@@ -1,22 +1,38 @@
-require 'openai'
+class Captain::Llm::EmbeddingService
+  include Integrations::LlmInstrumentation
 
-class Captain::Llm::EmbeddingService < Llm::LegacyBaseOpenAiService
   class EmbeddingsError < StandardError; end
 
-  def self.embedding_model
-    @embedding_model = InstallationConfig.find_by(name: 'CAPTAIN_EMBEDDING_MODEL')&.value.presence || OpenAiConstants::DEFAULT_EMBEDDING_MODEL
+  def initialize(account_id: nil)
+    Llm::Config.initialize!
+    @account_id = account_id
+    @embedding_model = InstallationConfig.find_by(name: 'CAPTAIN_EMBEDDING_MODEL')&.value.presence || LlmConstants::DEFAULT_EMBEDDING_MODEL
   end
 
-  def get_embedding(content, model: self.class.embedding_model)
-    response = @client.embeddings(
-      parameters: {
-        model: model,
-        input: content
-      }
-    )
+  def self.embedding_model
+    InstallationConfig.find_by(name: 'CAPTAIN_EMBEDDING_MODEL')&.value.presence || LlmConstants::DEFAULT_EMBEDDING_MODEL
+  end
 
-    response.dig('data', 0, 'embedding')
-  rescue StandardError => e
+  def get_embedding(content, model: @embedding_model)
+    return [] if content.blank?
+
+    instrument_embedding_call(instrumentation_params(content, model)) do
+      RubyLLM.embed(content, model: model).vectors
+    end
+  rescue RubyLLM::Error => e
+    Rails.logger.error "Embedding API Error: #{e.message}"
     raise EmbeddingsError, "Failed to create an embedding: #{e.message}"
   end
+
+  private
+
+  def instrumentation_params(content, model)
+    {
+      span_name: 'llm.captain.embedding',
+      model: model,
+      input: content,
+      feature_name: 'embedding',
+      account_id: @account_id
+    }
+  end
 end
diff --git a/enterprise/app/services/captain/llm/faq_generator_service.rb b/enterprise/app/services/captain/llm/faq_generator_service.rb
index 634385b36..b22a631b3 100644
--- a/enterprise/app/services/captain/llm/faq_generator_service.rb
+++ b/enterprise/app/services/captain/llm/faq_generator_service.rb
@@ -1,15 +1,24 @@
-class Captain::Llm::FaqGeneratorService < Llm::LegacyBaseOpenAiService
-  def initialize(content, language = 'english')
+class Captain::Llm::FaqGeneratorService < Llm::BaseAiService
+  include Integrations::LlmInstrumentation
+
+  def initialize(content, language = 'english', account_id: nil)
     super()
     @language = language
     @content = content
+    @account_id = account_id
   end
 
   def generate
-    response = @client.chat(parameters: chat_parameters)
-    parse_response(response)
-  rescue OpenAI::Error => e
-    Rails.logger.error "OpenAI API Error: #{e.message}"
+    response = instrument_llm_call(instrumentation_params) do
+      chat
+        .with_params(response_format: { type: 'json_object' })
+        .with_instructions(system_prompt)
+        .ask(@content)
+    end
+
+    parse_response(response.content)
+  rescue RubyLLM::Error => e
+    Rails.logger.error "LLM API Error: #{e.message}"
     []
   end
 
@@ -17,26 +26,25 @@ class Captain::Llm::FaqGeneratorService < Llm::LegacyBaseOpenAiService
 
   attr_reader :content, :language
 
-  def chat_parameters
-    prompt = Captain::Llm::SystemPromptsService.faq_generator(language)
+  def system_prompt
+    Captain::Llm::SystemPromptsService.faq_generator(language)
+  end
+
+  def instrumentation_params
     {
+      span_name: 'llm.captain.faq_generator',
       model: @model,
-      response_format: { type: 'json_object' },
+      temperature: @temperature,
+      feature_name: 'faq_generator',
+      account_id: @account_id,
       messages: [
-        {
-          role: 'system',
-          content: prompt
-        },
-        {
-          role: 'user',
-          content: content
-        }
+        { role: 'system', content: system_prompt },
+        { role: 'user', content: @content }
       ]
     }
   end
 
-  def parse_response(response)
-    content = response.dig('choices', 0, 'message', 'content')
+  def parse_response(content)
     return [] if content.nil?
 
     JSON.parse(content.strip).fetch('faqs', [])
diff --git a/enterprise/app/services/captain/llm/paginated_faq_generator_service.rb b/enterprise/app/services/captain/llm/paginated_faq_generator_service.rb
index ebfef4b5c..149152107 100644
--- a/enterprise/app/services/captain/llm/paginated_faq_generator_service.rb
+++ b/enterprise/app/services/captain/llm/paginated_faq_generator_service.rb
@@ -1,4 +1,6 @@
 class Captain::Llm::PaginatedFaqGeneratorService < Llm::LegacyBaseOpenAiService
+  include Integrations::LlmInstrumentation
+
   # Default pages per chunk - easily configurable
   DEFAULT_PAGES_PER_CHUNK = 10
   MAX_ITERATIONS = 20 # Safety limit to prevent infinite loops
@@ -13,7 +15,7 @@ class Captain::Llm::PaginatedFaqGeneratorService < Llm::LegacyBaseOpenAiService
     @max_pages = options[:max_pages] # Optional limit from UI
     @total_pages_processed = 0
     @iterations_completed = 0
-    @model = OpenAiConstants::PDF_PROCESSING_MODEL
+    @model = LlmConstants::PDF_PROCESSING_MODEL
   end
 
   def generate
@@ -43,7 +45,19 @@ class Captain::Llm::PaginatedFaqGeneratorService < Llm::LegacyBaseOpenAiService
   private
 
   def generate_standard_faqs
-    response = @client.chat(parameters: standard_chat_parameters)
+    params = standard_chat_parameters
+    instrumentation_params = {
+      span_name: 'llm.faq_generation',
+      account_id: @document&.account_id,
+      feature_name: 'faq_generation',
+      model: @model,
+      messages: params[:messages]
+    }
+
+    response = instrument_llm_call(instrumentation_params) do
+      @client.chat(parameters: params)
+    end
+
     parse_response(response)
   rescue OpenAI::Error => e
     Rails.logger.error I18n.t('captain.documents.openai_api_error', error: e.message)
@@ -84,7 +98,13 @@ class Captain::Llm::PaginatedFaqGeneratorService < Llm::LegacyBaseOpenAiService
 
   def process_page_chunk(start_page, end_page)
     params = build_chunk_parameters(start_page, end_page)
-    response = @client.chat(parameters: params)
+
+    instrumentation_params = build_instrumentation_params(params, start_page, end_page)
+
+    response = instrument_llm_call(instrumentation_params) do
+      @client.chat(parameters: params)
+    end
+
     result = parse_chunk_response(response)
     { faqs: result['faqs'] || [], has_content: result['has_content'] != false }
   rescue OpenAI::Error => e
@@ -180,21 +200,26 @@ class Captain::Llm::PaginatedFaqGeneratorService < Llm::LegacyBaseOpenAiService
   def similarity_score(str1, str2)
     words1 = str1.downcase.split(/\W+/).reject(&:empty?)
     words2 = str2.downcase.split(/\W+/).reject(&:empty?)
-
     common_words = words1 & words2
     total_words = (words1 + words2).uniq.size
-
     return 0 if total_words.zero?
 
     common_words.size.to_f / total_words
   end
 
-  def determine_stop_reason(last_chunk_result)
-    return 'Maximum iterations reached' if @iterations_completed >= MAX_ITERATIONS
-    return 'Maximum pages processed' if @max_pages && @total_pages_processed >= @max_pages
-    return 'No content found in last chunk' if last_chunk_result[:faqs].empty?
-    return 'End of document reached' if last_chunk_result[:has_content] == false
-
-    'Unknown'
+  def build_instrumentation_params(params, start_page, end_page)
+    {
+      span_name: 'llm.paginated_faq_generation',
+      account_id: @document&.account_id,
+      feature_name: 'paginated_faq_generation',
+      model: @model,
+      messages: params[:messages],
+      metadata: {
+        document_id: @document&.id,
+        start_page: start_page,
+        end_page: end_page,
+        iteration: @iterations_completed + 1
+      }
+    }
   end
 end
diff --git a/enterprise/app/services/captain/llm/pdf_processing_service.rb b/enterprise/app/services/captain/llm/pdf_processing_service.rb
index 55177b78d..82e3e9fbc 100644
--- a/enterprise/app/services/captain/llm/pdf_processing_service.rb
+++ b/enterprise/app/services/captain/llm/pdf_processing_service.rb
@@ -1,4 +1,6 @@
 class Captain::Llm::PdfProcessingService < Llm::LegacyBaseOpenAiService
+  include Integrations::LlmInstrumentation
+
   def initialize(document)
     super()
     @document = document
@@ -19,13 +21,30 @@ class Captain::Llm::PdfProcessingService < Llm::LegacyBaseOpenAiService
 
   def upload_pdf_to_openai
     with_tempfile do |temp_file|
-      response = @client.files.upload(
-        parameters: {
-          file: temp_file,
-          purpose: 'assistants'
-        }
-      )
-      response['id']
+      instrument_file_upload do
+        response = @client.files.upload(
+          parameters: {
+            file: temp_file,
+            purpose: 'assistants'
+          }
+        )
+        response['id']
+      end
+    end
+  end
+
+  def instrument_file_upload(&)
+    return yield unless ChatwootApp.otel_enabled?
+
+    tracer.in_span('llm.file.upload') do |span|
+      span.set_attribute('gen_ai.provider', 'openai')
+      span.set_attribute('file.purpose', 'assistants')
+      span.set_attribute(ATTR_LANGFUSE_USER_ID, document.account_id.to_s)
+      span.set_attribute(ATTR_LANGFUSE_TAGS, ['pdf_upload'].to_json)
+      span.set_attribute(format(ATTR_LANGFUSE_METADATA, 'document_id'), document.id.to_s)
+      file_id = yield
+      span.set_attribute('file.id', file_id) if file_id
+      file_id
     end
   end
 
diff --git a/enterprise/app/services/captain/onboarding/website_analyzer_service.rb b/enterprise/app/services/captain/onboarding/website_analyzer_service.rb
index 02ba35571..a5879ba33 100644
--- a/enterprise/app/services/captain/onboarding/website_analyzer_service.rb
+++ b/enterprise/app/services/captain/onboarding/website_analyzer_service.rb
@@ -1,4 +1,5 @@
-class Captain::Onboarding::WebsiteAnalyzerService < Llm::LegacyBaseOpenAiService
+class Captain::Onboarding::WebsiteAnalyzerService < Llm::BaseAiService
+  include Integrations::LlmInstrumentation
   MAX_CONTENT_LENGTH = 8000
 
   def initialize(website_url)
@@ -57,19 +58,29 @@ class Captain::Onboarding::WebsiteAnalyzerService < Llm::LegacyBaseOpenAiService
   end
 
   def extract_business_info
-    prompt = build_analysis_prompt
+    response = instrument_llm_call(instrumentation_params) do
+      chat
+        .with_params(response_format: { type: 'json_object' }, max_tokens: 1000)
+        .with_temperature(0.1)
+        .with_instructions(build_analysis_prompt)
+        .ask(@website_content)
+    end
 
-    response = client.chat(
-      parameters: {
-        model: model,
-        messages: [{ role: 'user', content: prompt }],
-        response_format: { type: 'json_object' },
-        temperature: 0.1,
-        max_tokens: 1000
-      }
-    )
+    parse_llm_response(response.content)
+  end
 
-    parse_llm_response(response.dig('choices', 0, 'message', 'content'))
+  def instrumentation_params
+    {
+      span_name: 'llm.captain.website_analyzer',
+      model: @model,
+      temperature: 0.1,
+      feature_name: 'website_analyzer',
+      messages: [
+        { role: 'system', content: build_analysis_prompt },
+        { role: 'user', content: @website_content }
+      ],
+      metadata: { website_url: @website_url }
+    }
   end
 
   def build_analysis_prompt
@@ -95,7 +106,7 @@ class Captain::Onboarding::WebsiteAnalyzerService < Llm::LegacyBaseOpenAiService
   end
 
   def parse_llm_response(response_text)
-    parsed_response = JSON.parse(response_text)
+    parsed_response = JSON.parse(response_text.strip)
 
     {
       success: true,
diff --git a/enterprise/app/services/enterprise/billing/handle_stripe_event_service.rb b/enterprise/app/services/enterprise/billing/handle_stripe_event_service.rb
index ecbc481a4..390786ec8 100644
--- a/enterprise/app/services/enterprise/billing/handle_stripe_event_service.rb
+++ b/enterprise/app/services/enterprise/billing/handle_stripe_event_service.rb
@@ -50,15 +50,19 @@ class Enterprise::Billing::HandleStripeEventService
     previous_usage = capture_previous_usage
     update_account_attributes(subscription, plan)
     update_plan_features
-    handle_subscription_credits(plan, previous_usage)
-    account.reset_response_usage
+
+    if billing_period_renewed?
+      ActiveRecord::Base.transaction do
+        handle_subscription_credits(plan, previous_usage)
+        account.reset_response_usage
+      end
+    elsif plan_changed?
+      handle_plan_change_credits(plan, previous_usage)
+    end
   end
 
   def capture_previous_usage
-    {
-      responses: account.custom_attributes['captain_responses_usage'].to_i,
-      monthly: current_plan_credits[:responses]
-    }
+    { responses: account.custom_attributes['captain_responses_usage'].to_i, monthly: current_plan_credits[:responses] }
   end
 
   def current_plan_credits
@@ -71,15 +75,15 @@ class Enterprise::Billing::HandleStripeEventService
   def update_account_attributes(subscription, plan)
     # https://stripe.com/docs/api/subscriptions/object
     account.update(
-      custom_attributes: {
-        stripe_customer_id: subscription.customer,
-        stripe_price_id: subscription['plan']['id'],
-        stripe_product_id: subscription['plan']['product'],
-        plan_name: plan['name'],
-        subscribed_quantity: subscription['quantity'],
-        subscription_status: subscription['status'],
-        subscription_ends_on: Time.zone.at(subscription['current_period_end'])
-      }
+      custom_attributes: account.custom_attributes.merge(
+        'stripe_customer_id' => subscription.customer,
+        'stripe_price_id' => subscription['plan']['id'],
+        'stripe_product_id' => subscription['plan']['product'],
+        'plan_name' => plan['name'],
+        'subscribed_quantity' => subscription['quantity'],
+        'subscription_status' => subscription['status'],
+        'subscription_ends_on' => Time.zone.at(subscription['current_period_end'])
+      )
     )
   end
 
@@ -131,6 +135,18 @@ class Enterprise::Billing::HandleStripeEventService
     account.update!(limits: current_limits.merge('captain_responses' => updated_credits))
   end
 
+  def handle_plan_change_credits(new_plan, previous_usage)
+    current_limits = account.limits || {}
+    current_credits = current_limits['captain_responses'].to_i
+
+    previous_plan_credits = previous_usage[:monthly]
+    new_plan_credits = get_plan_credits(new_plan['name'])[:responses]
+
+    updated_credits = current_credits - previous_plan_credits + new_plan_credits
+
+    account.update!(limits: current_limits.merge('captain_responses' => updated_credits))
+  end
+
   def get_plan_credits(plan_name)
     config = InstallationConfig.find_by(name: CAPTAIN_CLOUD_PLAN_LIMITS).value
     config = JSON.parse(config) if config.is_a?(String)
@@ -141,20 +157,12 @@ class Enterprise::Billing::HandleStripeEventService
     plan_name = account.custom_attributes['plan_name']
     return if plan_name.blank?
 
-    # Enable features based on plan hierarchy
     case plan_name
-    when 'Startups'
-      # Startups plan gets the basic features
-      account.enable_features(*STARTUP_PLAN_FEATURES)
+    when 'Startups' then account.enable_features(*STARTUP_PLAN_FEATURES)
     when 'Business'
-      # Business plan gets Startups features + Business features
-      account.enable_features(*STARTUP_PLAN_FEATURES)
-      account.enable_features(*BUSINESS_PLAN_FEATURES)
+      account.enable_features(*STARTUP_PLAN_FEATURES, *BUSINESS_PLAN_FEATURES)
     when 'Enterprise'
-      # Enterprise plan gets all features
-      account.enable_features(*STARTUP_PLAN_FEATURES)
-      account.enable_features(*BUSINESS_PLAN_FEATURES)
-      account.enable_features(*ENTERPRISE_PLAN_FEATURES)
+      account.enable_features(*STARTUP_PLAN_FEATURES, *BUSINESS_PLAN_FEATURES, *ENTERPRISE_PLAN_FEATURES)
     end
   end
 
@@ -162,6 +170,25 @@ class Enterprise::Billing::HandleStripeEventService
     @subscription ||= @event.data.object
   end
 
+  def previous_attributes
+    @previous_attributes ||= JSON.parse((@event.data.previous_attributes || {}).to_json)
+  end
+
+  def plan_changed?
+    return false if previous_attributes['plan'].blank?
+
+    previous_plan_id = previous_attributes.dig('plan', 'id')
+    current_plan_id = subscription['plan']['id']
+
+    previous_plan_id != current_plan_id
+  end
+
+  def billing_period_renewed?
+    return false if previous_attributes['current_period_start'].blank?
+
+    previous_attributes['current_period_start'] != subscription['current_period_start']
+  end
+
   def account
     @account ||= Account.where("custom_attributes->>'stripe_customer_id' = ?", subscription.customer).first
   end
diff --git a/enterprise/app/services/enterprise/message_templates/hook_execution_service.rb b/enterprise/app/services/enterprise/message_templates/hook_execution_service.rb
index ac1c3a95d..5c9a8a184 100644
--- a/enterprise/app/services/enterprise/message_templates/hook_execution_service.rb
+++ b/enterprise/app/services/enterprise/message_templates/hook_execution_service.rb
@@ -9,6 +9,24 @@ module Enterprise::MessageTemplates::HookExecutionService
     schedule_captain_response
   end
 
+  def should_send_greeting?
+    return false if captain_handling_conversation?
+
+    super
+  end
+
+  def should_send_out_of_office_message?
+    return false if captain_handling_conversation?
+
+    super
+  end
+
+  def should_send_email_collect?
+    return false if captain_handling_conversation?
+
+    super
+  end
+
   private
 
   def schedule_captain_response
@@ -46,5 +64,14 @@ module Enterprise::MessageTemplates::HookExecutionService
       content: 'Transferring to another agent for further assistance.'
     )
     conversation.bot_handoff!
+    send_out_of_office_message_after_handoff
+  end
+
+  def send_out_of_office_message_after_handoff
+    ::MessageTemplates::Template::OutOfOffice.perform_if_applicable(conversation)
+  end
+
+  def captain_handling_conversation?
+    conversation.pending? && inbox.respond_to?(:captain_assistant) && inbox.captain_assistant.present?
   end
 end
diff --git a/enterprise/app/services/internal/account_analysis/content_evaluator_service.rb b/enterprise/app/services/internal/account_analysis/content_evaluator_service.rb
index 586e9fad0..7be5647a8 100644
--- a/enterprise/app/services/internal/account_analysis/content_evaluator_service.rb
+++ b/enterprise/app/services/internal/account_analysis/content_evaluator_service.rb
@@ -1,48 +1,59 @@
-class Internal::AccountAnalysis::ContentEvaluatorService < Llm::LegacyBaseOpenAiService
-  def initialize
-    super()
+class Internal::AccountAnalysis::ContentEvaluatorService
+  include Integrations::LlmInstrumentation
 
-    @model = 'gpt-4o-mini'.freeze
+  def initialize
+    Llm::Config.initialize!
   end
 
   def evaluate(content)
     return default_evaluation if content.blank?
 
-    begin
-      response = send_to_llm(content)
-      evaluation = handle_response(response)
-      log_evaluation_results(evaluation)
-      evaluation
-    rescue StandardError => e
-      handle_evaluation_error(e)
+    moderation_result = instrument_moderation_call(instrumentation_params(content)) do
+      RubyLLM.moderate(content.to_s[0...10_000])
     end
+
+    build_evaluation(moderation_result)
+  rescue StandardError => e
+    handle_evaluation_error(e)
   end
 
   private
 
-  def send_to_llm(content)
-    Rails.logger.info('Sending content to LLM for security evaluation')
-    @client.chat(
-      parameters: {
-        model: @model,
-        messages: llm_messages(content),
-        response_format: { type: 'json_object' }
-      }
-    )
+  def instrumentation_params(content)
+    {
+      span_name: 'llm.internal.content_moderation',
+      model: 'text-moderation-latest',
+      input: content,
+      feature_name: 'content_evaluator'
+    }
   end
 
-  def handle_response(response)
-    return default_evaluation if response.nil?
+  def build_evaluation(result)
+    flagged = result.flagged?
+    categories = result.flagged_categories
 
-    parsed = JSON.parse(response.dig('choices', 0, 'message', 'content').strip)
-
-    {
-      'threat_level' => parsed['threat_level'] || 'unknown',
-      'threat_summary' => parsed['threat_summary'] || 'No threat summary provided',
-      'detected_threats' => parsed['detected_threats'] || [],
-      'illegal_activities_detected' => parsed['illegal_activities_detected'] || false,
-      'recommendation' => parsed['recommendation'] || 'review'
+    evaluation = {
+      'threat_level' => flagged ? determine_threat_level(result) : 'safe',
+      'threat_summary' => flagged ? "Content flagged for: #{categories.join(', ')}" : 'No threats detected',
+      'detected_threats' => categories,
+      'illegal_activities_detected' => categories.any? { |c| c.include?('violence') || c.include?('self-harm') },
+      'recommendation' => flagged ? 'review' : 'approve'
     }
+
+    log_evaluation_results(evaluation)
+    evaluation
+  end
+
+  def determine_threat_level(result)
+    scores = result.category_scores
+    max_score = scores.values.max || 0
+
+    case max_score
+    when 0.8.. then 'critical'
+    when 0.5..0.8 then 'high'
+    when 0.2..0.5 then 'medium'
+    else 'low'
+    end
   end
 
   def default_evaluation(error_type = nil)
@@ -56,18 +67,11 @@ class Internal::AccountAnalysis::ContentEvaluatorService < Llm::LegacyBaseOpenAi
   end
 
   def log_evaluation_results(evaluation)
-    Rails.logger.info("LLM evaluation - Level: #{evaluation['threat_level']}, Illegal activities: #{evaluation['illegal_activities_detected']}")
+    Rails.logger.info("Moderation evaluation - Level: #{evaluation['threat_level']}, Threats: #{evaluation['detected_threats'].join(', ')}")
   end
 
   def handle_evaluation_error(error)
     Rails.logger.error("Error evaluating content: #{error.message}")
     default_evaluation('evaluation_failure')
   end
-
-  def llm_messages(content)
-    [
-      { role: 'system', content: 'You are a security analysis system that evaluates content for potential threats and scams.' },
-      { role: 'user', content: Internal::AccountAnalysis::PromptsService.threat_analyser(content.to_s[0...10_000]) }
-    ]
-  end
 end
diff --git a/enterprise/app/services/llm/base_ai_service.rb b/enterprise/app/services/llm/base_ai_service.rb
index 504685e3a..a5a91cf24 100644
--- a/enterprise/app/services/llm/base_ai_service.rb
+++ b/enterprise/app/services/llm/base_ai_service.rb
@@ -14,8 +14,6 @@ class Llm::BaseAiService
     setup_temperature
   end
 
-  # Returns a configured RubyLLM chat instance.
-  # Subclasses can override model/temperature via instance variables or pass them explicitly.
   def chat(model: @model, temperature: @temperature)
     RubyLLM.chat(model: model).with_temperature(temperature)
   end
diff --git a/enterprise/app/services/llm/legacy_base_open_ai_service.rb b/enterprise/app/services/llm/legacy_base_open_ai_service.rb
index ede9f0d8f..f431830db 100644
--- a/enterprise/app/services/llm/legacy_base_open_ai_service.rb
+++ b/enterprise/app/services/llm/legacy_base_open_ai_service.rb
@@ -1,8 +1,11 @@
 # frozen_string_literal: true
 
 # DEPRECATED: This class uses the legacy OpenAI Ruby gem directly.
-# New features should use Llm::BaseAiService with RubyLLM instead.
-# This class will be removed once all services are migrated to RubyLLM.
+# Only used for PDF/file operations that require OpenAI's files API:
+# - Captain::Llm::PdfProcessingService (files.upload for assistants)
+# - Captain::Llm::PaginatedFaqGeneratorService (uses file_id from uploaded files)
+#
+# For all other LLM operations, use Llm::BaseAiService with RubyLLM instead.
 class Llm::LegacyBaseOpenAiService
   DEFAULT_MODEL = 'gpt-4o-mini'
 
diff --git a/enterprise/app/services/messages/audio_transcription_service.rb b/enterprise/app/services/messages/audio_transcription_service.rb
index d3cc91376..1676dd862 100644
--- a/enterprise/app/services/messages/audio_transcription_service.rb
+++ b/enterprise/app/services/messages/audio_transcription_service.rb
@@ -1,4 +1,8 @@
-class Messages::AudioTranscriptionService < Llm::LegacyBaseOpenAiService
+class Messages::AudioTranscriptionService< Llm::LegacyBaseOpenAiService
+  include Integrations::LlmInstrumentation
+
+  WHISPER_MODEL = 'whisper-1'.freeze
+
   attr_reader :attachment, :message, :account
 
   def initialize(attachment)
@@ -46,7 +50,7 @@ class Messages::AudioTranscriptionService < Llm::LegacyBaseOpenAiService
 
     temp_file_path = fetch_audio_file
 
-    response_text = nil
+    transcribed_text = nil
 
     File.open(temp_file_path, 'rb') do |file|
       response = @client.audio.transcribe(
@@ -56,14 +60,23 @@ class Messages::AudioTranscriptionService < Llm::LegacyBaseOpenAiService
           temperature: 0.4
         }
       )
-
-      response_text = response['text']
+      transcribed_text = response['text']
     end
 
     FileUtils.rm_f(temp_file_path)
 
-    update_transcription(response_text)
-    response_text
+    update_transcription(transcribed_text)
+    transcribed_text
+  end
+
+  def instrumentation_params(file_path)
+    {
+      span_name: 'llm.messages.audio_transcription',
+      model: WHISPER_MODEL,
+      account_id: account&.id,
+      feature_name: 'audio_transcription',
+      file_path: file_path
+    }
   end
 
   def update_transcription(transcribed_text)
diff --git a/enterprise/lib/captain/agent.rb b/enterprise/lib/captain/agent.rb
deleted file mode 100644
index f0b511115..000000000
--- a/enterprise/lib/captain/agent.rb
+++ /dev/null
@@ -1,137 +0,0 @@
-require 'openai'
-class Captain::Agent
-  attr_reader :name, :tools, :prompt, :persona, :goal, :secrets
-
-  def initialize(name:, config:)
-    @name = name
-    @prompt = construct_prompt(config)
-    @tools = prepare_tools(config[:tools] || [])
-    @messages = config[:messages] || []
-    @max_iterations = config[:max_iterations] || 10
-    @llm = Captain::LlmService.new(api_key: config[:secrets][:OPENAI_API_KEY])
-    @logger = Rails.logger
-
-    @logger.info(@prompt)
-  end
-
-  def execute(input, context)
-    setup_messages(input, context)
-    result = {}
-    @max_iterations.times do |iteration|
-      push_to_messages(role: 'system', content: 'Provide a final answer') if iteration == @max_iterations - 1
-
-      result = @llm.call(@messages, functions)
-      handle_llm_result(result)
-
-      break if result[:stop]
-    end
-
-    result[:output]
-  end
-
-  def register_tool(tool)
-    @tools << tool
-  end
-
-  private
-
-  def setup_messages(input, context)
-    if @messages.empty?
-      push_to_messages({ role: 'system', content: @prompt })
-      push_to_messages({ role: 'assistant', content: context }) if context.present?
-    end
-    push_to_messages({ role: 'user', content: input })
-  end
-
-  def handle_llm_result(result)
-    if result[:tool_call]
-      tool_result = execute_tool(result[:tool_call])
-      push_to_messages({ role: 'assistant', content: tool_result })
-    else
-      push_to_messages({ role: 'assistant', content: result[:output] })
-    end
-    result[:output]
-  end
-
-  def execute_tool(tool_call)
-    function_name = tool_call['function']['name']
-    arguments = JSON.parse(tool_call['function']['arguments'])
-
-    tool = @tools.find { |t| t.name == function_name }
-    tool.execute(arguments, {})
-  rescue StandardError => e
-    "Tool execution failed: #{e.message}"
-  end
-
-  def construct_prompt(config)
-    return config[:prompt] if config[:prompt]
-
-    <<~PROMPT
-      Persona: #{config[:persona]}
-      Objective: #{config[:goal]}
-
-      Guidelines:
-      - Persistently work towards achieving the stated objective without deviation.
-      - Use only the provided tools to complete the task. Avoid inventing or assuming function names.
-      - Set `'stop': true` once the objective is fully achieved.
-      - DO NOT return tool usage as the final result.
-      - If sufficient information is available to deliver result, compile and present it to the user.
-      - Always return a final result and ENSURE the final result is formatted in Markdown.
-
-      Output Structure:
-
-      1. **Tool Usage:**
-        - If a relevant function is identified, call it directly without unnecessary explanations.
-
-      2. **Final Answer:**
-        When ready to provide a complete response, follow this JSON format:
-
-        ```json
-        {
-          "thought_process": "Explain the reasoning and steps taken to arrive at the final result.",
-          "result": "Provide the complete response in clear, structured text.",
-          "stop": true
-        }
-    PROMPT
-  end
-
-  def prepare_tools(tools = [])
-    tools.map do |_, tool|
-      Captain::Tool.new(
-        name: tool['name'],
-        config: {
-          description: tool['description'],
-          properties: tool['properties'],
-          secrets: tool['secrets'],
-          implementation: tool['implementation']
-        }
-      )
-    end
-  end
-
-  def functions
-    @tools.map do |tool|
-      properties = {}
-      tool.properties.each do |property_name, property_details|
-        properties[property_name] = {
-          type: property_details[:type],
-          description: property_details[:description]
-        }
-      end
-      required = tool.properties.select { |_, details| details[:required] == true }.keys
-      {
-        type: 'function',
-        function: {
-          name: tool.name,
-          description: tool.description,
-          parameters: { type: 'object', properties: properties, required: required }
-        }
-      }
-    end
-  end
-
-  def push_to_messages(message)
-    @logger.info("\n\n\nMessage: #{message}\n\n\n")
-    @messages << message
-  end
-end
diff --git a/enterprise/lib/captain/llm_service.rb b/enterprise/lib/captain/llm_service.rb
deleted file mode 100644
index f0faa1002..000000000
--- a/enterprise/lib/captain/llm_service.rb
+++ /dev/null
@@ -1,64 +0,0 @@
-require 'openai'
-
-class Captain::LlmService
-  def initialize(config)
-    @client = OpenAI::Client.new(
-      access_token: config[:api_key],
-      log_errors: Rails.env.development?
-    )
-    @logger = Rails.logger
-  end
-
-  def call(messages, functions = [])
-    openai_params = {
-      model: 'gpt-4o',
-      response_format: { type: 'json_object' },
-      messages: messages
-    }
-    openai_params[:tools] = functions if functions.any?
-
-    response = @client.chat(parameters: openai_params)
-    handle_response(response)
-  rescue StandardError => e
-    handle_error(e)
-  end
-
-  private
-
-  def handle_response(response)
-    if response['choices'][0]['message']['tool_calls']
-      handle_tool_calls(response)
-    else
-      handle_direct_response(response)
-    end
-  end
-
-  def handle_tool_calls(response)
-    tool_call = response['choices'][0]['message']['tool_calls'][0]
-    {
-      tool_call: tool_call,
-      output: nil,
-      stop: false
-    }
-  end
-
-  def handle_direct_response(response)
-    content = response.dig('choices', 0, 'message', 'content').strip
-    parsed = JSON.parse(content)
-
-    {
-      output: parsed['result'] || parsed['thought_process'],
-      stop: parsed['stop'] || false
-    }
-  rescue JSON::ParserError => e
-    handle_error(e, content)
-  end
-
-  def handle_error(error, content = nil)
-    @logger.error("LLM call failed: #{error.message}")
-    @logger.error(error.backtrace.join("\n"))
-    @logger.error("Content: #{content}") if content
-
-    { output: 'Error occurred, retrying', stop: false }
-  end
-end
diff --git a/enterprise/lib/captain/tool.rb b/enterprise/lib/captain/tool.rb
deleted file mode 100644
index b3ed6f69f..000000000
--- a/enterprise/lib/captain/tool.rb
+++ /dev/null
@@ -1,66 +0,0 @@
-class Captain::Tool
-  class InvalidImplementationError < StandardError; end
-  class InvalidSecretsError < StandardError; end
-  class ExecutionError < StandardError; end
-
-  REQUIRED_PROPERTIES = %w[name description properties secrets].freeze
-
-  attr_reader :name, :description, :properties, :secrets, :implementation, :memory
-
-  def initialize(name:, config:)
-    @name = name
-    @description = config[:description]
-    @properties =  config[:properties]
-    @secrets =  config[:secrets] || []
-    @implementation = config[:implementation]
-    @memory = config[:memory] || {}
-  end
-
-  def register_method(&block)
-    @implementation = block
-  end
-
-  def execute(input, provided_secrets = {})
-    validate_secrets!(provided_secrets)
-    validate_input!(input)
-
-    raise ExecutionError, 'No implementation registered' unless @implementation
-
-    instance_exec(input, provided_secrets, memory, &@implementation)
-  rescue StandardError => e
-    raise ExecutionError, "Execution failed: #{e.message}"
-  end
-
-  private
-
-  def validate_config!(config)
-    missing_keys = REQUIRED_PROPERTIES - config.keys
-    return if missing_keys.empty?
-
-    raise InvalidImplementationError,
-          "Missing required properties: #{missing_keys.join(', ')}"
-  end
-
-  def validate_secrets!(provided_secrets)
-    required_secrets = secrets.map!(&:to_sym)
-    missing_secrets = required_secrets - provided_secrets.keys
-
-    return if missing_secrets.empty?
-
-    raise InvalidSecretsError, "Missing required secrets: #{missing_secrets.join(', ')}"
-  end
-
-  def validate_input!(input)
-    properties.each do |property, constraints|
-      validate_property!(input, property, constraints)
-    end
-  end
-
-  def validate_property!(input, property, constraints)
-    value = input[property.to_sym]
-
-    raise ArgumentError, "Missing required property: #{property}" if constraints['required'] && value.nil?
-
-    true
-  end
-end
diff --git a/enterprise/lib/captain/tools/handoff_tool.rb b/enterprise/lib/captain/tools/handoff_tool.rb
index 49f7c5a65..797f248ff 100644
--- a/enterprise/lib/captain/tools/handoff_tool.rb
+++ b/enterprise/lib/captain/tools/handoff_tool.rb
@@ -36,6 +36,13 @@ class Captain::Tools::HandoffTool < Captain::Tools::BasePublicTool
 
     # Trigger the bot handoff (sets status to open + dispatches events)
     conversation.bot_handoff!
+
+    # Send out of office message if applicable (since template messages were suppressed while Captain was handling)
+    send_out_of_office_message_if_applicable(conversation)
+  end
+
+  def send_out_of_office_message_if_applicable(conversation)
+    ::MessageTemplates::Template::OutOfOffice.perform_if_applicable(conversation)
   end
 
   # TODO: Future enhancement - Add team assignment capability
diff --git a/enterprise/lib/captain/tools/http_tool.rb b/enterprise/lib/captain/tools/http_tool.rb
index b634de04e..b4593d27f 100644
--- a/enterprise/lib/captain/tools/http_tool.rb
+++ b/enterprise/lib/captain/tools/http_tool.rb
@@ -11,11 +11,11 @@ class Captain::Tools::HttpTool < Agents::Tool
     @custom_tool.enabled?
   end
 
-  def perform(_tool_context, **params)
+  def perform(tool_context, **params)
     url = @custom_tool.build_request_url(params)
     body = @custom_tool.build_request_body(params)
 
-    response = execute_http_request(url, body)
+    response = execute_http_request(url, body, tool_context)
     @custom_tool.format_response(response.body)
   rescue StandardError => e
     Rails.logger.error("HttpTool execution error for #{@custom_tool.slug}: #{e.class} - #{e.message}")
@@ -39,7 +39,7 @@ class Captain::Tools::HttpTool < Agents::Tool
   # 1MB of text ≈ 250K tokens, which exceeds most LLM context windows
   MAX_RESPONSE_SIZE = 1.megabyte
 
-  def execute_http_request(url, body)
+  def execute_http_request(url, body, tool_context)
     uri = URI.parse(url)
 
     # Check if resolved IP is private
@@ -53,6 +53,7 @@ class Captain::Tools::HttpTool < Agents::Tool
 
     request = build_http_request(uri, body)
     apply_authentication(request)
+    apply_metadata_headers(request, tool_context)
 
     response = http.request(request)
 
@@ -102,4 +103,10 @@ class Captain::Tools::HttpTool < Agents::Tool
     credentials = @custom_tool.build_basic_auth_credentials
     request.basic_auth(*credentials) if credentials
   end
+
+  def apply_metadata_headers(request, tool_context)
+    state = tool_context&.state || {}
+    metadata_headers = @custom_tool.build_metadata_headers(state)
+    metadata_headers.each { |key, value| request[key] = value }
+  end
 end
diff --git a/lib/chatwoot_markdown_renderer.rb b/lib/chatwoot_markdown_renderer.rb
index db3e03a91..50d1755ee 100644
--- a/lib/chatwoot_markdown_renderer.rb
+++ b/lib/chatwoot_markdown_renderer.rb
@@ -5,7 +5,7 @@ class ChatwootMarkdownRenderer
 
   def render_message
     markdown_renderer = BaseMarkdownRenderer.new
-    doc = CommonMarker.render_doc(@content, :DEFAULT)
+    doc = CommonMarker.render_doc(@content, :DEFAULT, [:strikethrough])
     html = markdown_renderer.render(doc)
     render_as_html_safe(html)
   end
diff --git a/lib/integrations/llm_instrumentation.rb b/lib/integrations/llm_instrumentation.rb
index aff41fbce..34281c738 100644
--- a/lib/integrations/llm_instrumentation.rb
+++ b/lib/integrations/llm_instrumentation.rb
@@ -7,14 +7,6 @@ module Integrations::LlmInstrumentation
   include Integrations::LlmInstrumentationHelpers
   include Integrations::LlmInstrumentationSpans
 
-  PROVIDER_PREFIXES = {
-    'openai' => %w[gpt- o1 o3 o4 text-embedding- whisper- tts-],
-    'anthropic' => %w[claude-],
-    'google' => %w[gemini-],
-    'mistral' => %w[mistral- codestral-],
-    'deepseek' => %w[deepseek-]
-  }.freeze
-
   def instrument_llm_call(params)
     return yield unless ChatwootApp.otel_enabled?
 
@@ -66,16 +58,57 @@ module Integrations::LlmInstrumentation
     end
   end
 
-  def determine_provider(model_name)
-    return 'openai' if model_name.blank?
+  def instrument_embedding_call(params)
+    return yield unless ChatwootApp.otel_enabled?
 
-    model = model_name.to_s.downcase
-
-    PROVIDER_PREFIXES.each do |provider, prefixes|
-      return provider if prefixes.any? { |prefix| model.start_with?(prefix) }
+    instrument_with_span(params[:span_name] || 'llm.embedding', params) do |span, track_result|
+      set_embedding_span_attributes(span, params)
+      result = yield
+      track_result.call(result)
+      set_embedding_result_attributes(span, result)
+      result
     end
+  end
 
-    'openai'
+  def instrument_audio_transcription(params)
+    return yield unless ChatwootApp.otel_enabled?
+
+    instrument_with_span(params[:span_name] || 'llm.audio.transcription', params) do |span, track_result|
+      set_audio_transcription_span_attributes(span, params)
+      result = yield
+      track_result.call(result)
+      set_transcription_result_attributes(span, result)
+      result
+    end
+  end
+
+  def instrument_moderation_call(params)
+    return yield unless ChatwootApp.otel_enabled?
+
+    instrument_with_span(params[:span_name] || 'llm.moderation', params) do |span, track_result|
+      set_moderation_span_attributes(span, params)
+      result = yield
+      track_result.call(result)
+      set_moderation_result_attributes(span, result)
+      result
+    end
+  end
+
+  def instrument_with_span(span_name, params, &)
+    result = nil
+    executed = false
+    tracer.in_span(span_name) do |span|
+      track_result = lambda do |r|
+        executed = true
+        result = r
+      end
+      yield(span, track_result)
+    end
+  rescue StandardError => e
+    ChatwootExceptionTracker.new(e, account: resolve_account(params)).capture_exception
+    raise unless executed
+
+    result
   end
 
   private
@@ -86,36 +119,4 @@ module Integrations::LlmInstrumentation
 
     nil
   end
-
-  def setup_span_attributes(span, params)
-    set_request_attributes(span, params)
-    set_prompt_messages(span, params[:messages])
-    set_metadata_attributes(span, params)
-  end
-
-  def record_completion(span, result)
-    if result.respond_to?(:content)
-      span.set_attribute(ATTR_GEN_AI_COMPLETION_ROLE, result.role.to_s) if result.respond_to?(:role)
-      span.set_attribute(ATTR_GEN_AI_COMPLETION_CONTENT, result.content.to_s)
-    elsif result.is_a?(Hash)
-      set_completion_attributes(span, result) if result.is_a?(Hash)
-    end
-  end
-
-  def set_request_attributes(span, params)
-    provider = determine_provider(params[:model])
-    span.set_attribute(ATTR_GEN_AI_PROVIDER, provider)
-    span.set_attribute(ATTR_GEN_AI_REQUEST_MODEL, params[:model])
-    span.set_attribute(ATTR_GEN_AI_REQUEST_TEMPERATURE, params[:temperature]) if params[:temperature]
-  end
-
-  def set_prompt_messages(span, messages)
-    messages.each_with_index do |msg, idx|
-      role = msg[:role] || msg['role']
-      content = msg[:content] || msg['content']
-
-      span.set_attribute(format(ATTR_GEN_AI_PROMPT_ROLE, idx), role)
-      span.set_attribute(format(ATTR_GEN_AI_PROMPT_CONTENT, idx), content.to_s)
-    end
-  end
 end
diff --git a/lib/integrations/llm_instrumentation_completion_helpers.rb b/lib/integrations/llm_instrumentation_completion_helpers.rb
new file mode 100644
index 000000000..50e071119
--- /dev/null
+++ b/lib/integrations/llm_instrumentation_completion_helpers.rb
@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Integrations::LlmInstrumentationCompletionHelpers
+  include Integrations::LlmInstrumentationConstants
+
+  private
+
+  def set_embedding_span_attributes(span, params)
+    span.set_attribute(ATTR_GEN_AI_PROVIDER, determine_provider(params[:model]))
+    span.set_attribute(ATTR_GEN_AI_REQUEST_MODEL, params[:model])
+    span.set_attribute('embedding.input_length', params[:input]&.length || 0)
+    span.set_attribute(ATTR_LANGFUSE_OBSERVATION_INPUT, params[:input].to_s)
+    set_common_span_metadata(span, params)
+  end
+
+  def set_audio_transcription_span_attributes(span, params)
+    span.set_attribute(ATTR_GEN_AI_PROVIDER, 'openai')
+    span.set_attribute(ATTR_GEN_AI_REQUEST_MODEL, params[:model] || 'whisper-1')
+    span.set_attribute('audio.duration_seconds', params[:duration]) if params[:duration]
+    span.set_attribute(ATTR_LANGFUSE_OBSERVATION_INPUT, params[:file_path].to_s) if params[:file_path]
+    set_common_span_metadata(span, params)
+  end
+
+  def set_moderation_span_attributes(span, params)
+    span.set_attribute(ATTR_GEN_AI_PROVIDER, 'openai')
+    span.set_attribute(ATTR_GEN_AI_REQUEST_MODEL, params[:model] || 'text-moderation-latest')
+    span.set_attribute('moderation.input_length', params[:input]&.length || 0)
+    span.set_attribute(ATTR_LANGFUSE_OBSERVATION_INPUT, params[:input].to_s)
+    set_common_span_metadata(span, params)
+  end
+
+  def set_common_span_metadata(span, params)
+    span.set_attribute(ATTR_LANGFUSE_USER_ID, params[:account_id].to_s) if params[:account_id]
+    span.set_attribute(ATTR_LANGFUSE_TAGS, [params[:feature_name]].to_json) if params[:feature_name]
+  end
+
+  def set_embedding_result_attributes(span, result)
+    span.set_attribute('embedding.dimensions', result&.length || 0) if result.is_a?(Array)
+    span.set_attribute(ATTR_LANGFUSE_OBSERVATION_OUTPUT, "[#{result&.length || 0} dimensions]")
+  end
+
+  def set_transcription_result_attributes(span, result)
+    transcribed_text = result.respond_to?(:text) ? result.text : result.to_s
+    span.set_attribute('transcription.length', transcribed_text&.length || 0)
+    span.set_attribute(ATTR_LANGFUSE_OBSERVATION_OUTPUT, transcribed_text.to_s)
+  end
+
+  def set_moderation_result_attributes(span, result)
+    span.set_attribute('moderation.flagged', result.flagged?) if result.respond_to?(:flagged?)
+    span.set_attribute('moderation.categories', result.flagged_categories.to_json) if result.respond_to?(:flagged_categories)
+    output = {
+      flagged: result.respond_to?(:flagged?) ? result.flagged? : nil,
+      categories: result.respond_to?(:flagged_categories) ? result.flagged_categories : []
+    }
+    span.set_attribute(ATTR_LANGFUSE_OBSERVATION_OUTPUT, output.to_json)
+  end
+
+  def set_completion_attributes(span, result)
+    set_completion_message(span, result)
+    set_usage_metrics(span, result)
+    set_error_attributes(span, result)
+  end
+
+  def set_completion_message(span, result)
+    message = result[:message] || result.dig('choices', 0, 'message', 'content')
+    return if message.blank?
+
+    span.set_attribute(ATTR_GEN_AI_COMPLETION_ROLE, 'assistant')
+    span.set_attribute(ATTR_GEN_AI_COMPLETION_CONTENT, message)
+  end
+
+  def set_usage_metrics(span, result)
+    usage = result[:usage] || result['usage']
+    return if usage.blank?
+
+    span.set_attribute(ATTR_GEN_AI_USAGE_INPUT_TOKENS, usage['prompt_tokens']) if usage['prompt_tokens']
+    span.set_attribute(ATTR_GEN_AI_USAGE_OUTPUT_TOKENS, usage['completion_tokens']) if usage['completion_tokens']
+    span.set_attribute(ATTR_GEN_AI_USAGE_TOTAL_TOKENS, usage['total_tokens']) if usage['total_tokens']
+  end
+
+  def set_error_attributes(span, result)
+    error = result[:error] || result['error']
+    return if error.blank?
+
+    span.set_attribute(ATTR_GEN_AI_RESPONSE_ERROR, error.to_json)
+    span.status = OpenTelemetry::Trace::Status.error(error.to_s.truncate(1000))
+  end
+end
diff --git a/lib/integrations/llm_instrumentation_helpers.rb b/lib/integrations/llm_instrumentation_helpers.rb
index c03e3e9c7..129092ed4 100644
--- a/lib/integrations/llm_instrumentation_helpers.rb
+++ b/lib/integrations/llm_instrumentation_helpers.rb
@@ -2,38 +2,52 @@
 
 module Integrations::LlmInstrumentationHelpers
   include Integrations::LlmInstrumentationConstants
+  include Integrations::LlmInstrumentationCompletionHelpers
+
+  def determine_provider(model_name)
+    return 'openai' if model_name.blank?
+
+    model = model_name.to_s.downcase
+
+    LlmConstants::PROVIDER_PREFIXES.each do |provider, prefixes|
+      return provider if prefixes.any? { |prefix| model.start_with?(prefix) }
+    end
+
+    'openai'
+  end
 
   private
 
-  def set_completion_attributes(span, result)
-    set_completion_message(span, result)
-    set_usage_metrics(span, result)
-    set_error_attributes(span, result)
+  def setup_span_attributes(span, params)
+    set_request_attributes(span, params)
+    set_prompt_messages(span, params[:messages])
+    set_metadata_attributes(span, params)
   end
 
-  def set_completion_message(span, result)
-    message = result[:message] || result.dig('choices', 0, 'message', 'content')
-    return if message.blank?
-
-    span.set_attribute(ATTR_GEN_AI_COMPLETION_ROLE, 'assistant')
-    span.set_attribute(ATTR_GEN_AI_COMPLETION_CONTENT, message)
+  def record_completion(span, result)
+    if result.respond_to?(:content)
+      span.set_attribute(ATTR_GEN_AI_COMPLETION_ROLE, result.role.to_s) if result.respond_to?(:role)
+      span.set_attribute(ATTR_GEN_AI_COMPLETION_CONTENT, result.content.to_s)
+    elsif result.is_a?(Hash)
+      set_completion_attributes(span, result)
+    end
   end
 
-  def set_usage_metrics(span, result)
-    usage = result[:usage] || result['usage']
-    return if usage.blank?
-
-    span.set_attribute(ATTR_GEN_AI_USAGE_INPUT_TOKENS, usage['prompt_tokens']) if usage['prompt_tokens']
-    span.set_attribute(ATTR_GEN_AI_USAGE_OUTPUT_TOKENS, usage['completion_tokens']) if usage['completion_tokens']
-    span.set_attribute(ATTR_GEN_AI_USAGE_TOTAL_TOKENS, usage['total_tokens']) if usage['total_tokens']
+  def set_request_attributes(span, params)
+    provider = determine_provider(params[:model])
+    span.set_attribute(ATTR_GEN_AI_PROVIDER, provider)
+    span.set_attribute(ATTR_GEN_AI_REQUEST_MODEL, params[:model])
+    span.set_attribute(ATTR_GEN_AI_REQUEST_TEMPERATURE, params[:temperature]) if params[:temperature]
   end
 
-  def set_error_attributes(span, result)
-    error = result[:error] || result['error']
-    return if error.blank?
+  def set_prompt_messages(span, messages)
+    messages.each_with_index do |msg, idx|
+      role = msg[:role] || msg['role']
+      content = msg[:content] || msg['content']
 
-    span.set_attribute(ATTR_GEN_AI_RESPONSE_ERROR, error.to_json)
-    span.status = OpenTelemetry::Trace::Status.error(error.to_s.truncate(1000))
+      span.set_attribute(format(ATTR_GEN_AI_PROMPT_ROLE, idx), role)
+      span.set_attribute(format(ATTR_GEN_AI_PROMPT_CONTENT, idx), content.to_s)
+    end
   end
 
   def set_metadata_attributes(span, params)
diff --git a/lib/integrations/llm_instrumentation_spans.rb b/lib/integrations/llm_instrumentation_spans.rb
index 9199aaa10..824b6aa4a 100644
--- a/lib/integrations/llm_instrumentation_spans.rb
+++ b/lib/integrations/llm_instrumentation_spans.rb
@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require 'opentelemetry_config'
-require_relative 'llm_instrumentation_constants'
 
 module Integrations::LlmInstrumentationSpans
   include Integrations::LlmInstrumentationConstants
diff --git a/lib/integrations/openai/processor_service.rb b/lib/integrations/openai/processor_service.rb
index 0a0dfa8ae..2f0180701 100644
--- a/lib/integrations/openai/processor_service.rb
+++ b/lib/integrations/openai/processor_service.rb
@@ -77,21 +77,22 @@ class Integrations::Openai::ProcessorService < Integrations::LlmBaseService
   end
 
   def add_message_if_within_limit(character_count, message, messages, in_array_format)
-    if valid_message?(message, character_count)
-      add_message_to_list(message, messages, in_array_format)
-      character_count += message.content.length
+    content = message.content_for_llm
+    if valid_message?(content, character_count)
+      add_message_to_list(message, messages, in_array_format, content)
+      character_count += content.length
       [character_count, true]
     else
       [character_count, false]
     end
   end
 
-  def valid_message?(message, character_count)
-    message.content.present? && character_count + message.content.length <= TOKEN_LIMIT
+  def valid_message?(content, character_count)
+    content.present? && character_count + content.length <= TOKEN_LIMIT
   end
 
-  def add_message_to_list(message, messages, in_array_format)
-    formatted_message = format_message(message, in_array_format)
+  def add_message_to_list(message, messages, in_array_format, content)
+    formatted_message = format_message(message, in_array_format, content)
     messages.prepend(formatted_message)
   end
 
@@ -99,17 +100,17 @@ class Integrations::Openai::ProcessorService < Integrations::LlmBaseService
     in_array_format ? [] : ''
   end
 
-  def format_message(message, in_array_format)
-    in_array_format ? format_message_in_array(message) : format_message_in_string(message)
+  def format_message(message, in_array_format, content)
+    in_array_format ? format_message_in_array(message, content) : format_message_in_string(message, content)
   end
 
-  def format_message_in_array(message)
-    { role: (message.incoming? ? 'user' : 'assistant'), content: message.content }
+  def format_message_in_array(message, content)
+    { role: (message.incoming? ? 'user' : 'assistant'), content: content }
   end
 
-  def format_message_in_string(message)
+  def format_message_in_string(message, content)
     sender_type = message.incoming? ? 'Customer' : 'Agent'
-    "#{sender_type} #{message.sender&.name} : #{message.content}\n"
+    "#{sender_type} #{message.sender&.name} : #{content}\n"
   end
 
   def summarize_body
diff --git a/lib/llm_constants.rb b/lib/llm_constants.rb
new file mode 100644
index 000000000..054b775a5
--- /dev/null
+++ b/lib/llm_constants.rb
@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module LlmConstants
+  DEFAULT_MODEL = 'gpt-4.1-mini'
+  DEFAULT_EMBEDDING_MODEL = 'text-embedding-3-small'
+  PDF_PROCESSING_MODEL = 'gpt-4.1-mini'
+
+  OPENAI_API_ENDPOINT = 'https://api.openai.com'
+
+  PROVIDER_PREFIXES = {
+    'openai' => %w[gpt- o1 o3 o4 text-embedding- whisper- tts-],
+    'anthropic' => %w[claude-],
+    'google' => %w[gemini-],
+    'mistral' => %w[mistral- codestral-],
+    'deepseek' => %w[deepseek-]
+  }.freeze
+end
diff --git a/lib/open_ai_constants.rb b/lib/open_ai_constants.rb
deleted file mode 100644
index 2094567a7..000000000
--- a/lib/open_ai_constants.rb
+++ /dev/null
@@ -1,8 +0,0 @@
-# frozen_string_literal: true
-
-module OpenAiConstants
-  DEFAULT_MODEL = 'gpt-4.1-mini'
-  DEFAULT_ENDPOINT = 'https://api.openai.com'
-  DEFAULT_EMBEDDING_MODEL = 'text-embedding-3-small'
-  PDF_PROCESSING_MODEL = 'gpt-4.1-mini'
-end
diff --git a/lib/tasks/apply_sla.rake b/lib/tasks/apply_sla.rake
new file mode 100644
index 000000000..70adf8cf3
--- /dev/null
+++ b/lib/tasks/apply_sla.rake
@@ -0,0 +1,100 @@
+# Apply SLA Policy to Conversations
+#
+# This task applies an SLA policy to existing conversations that don't have one assigned.
+# It processes conversations in batches and only affects conversations with sla_policy_id = nil.
+#
+# Usage Examples:
+#   # Using arguments (may need escaping in some shells)
+#   bundle exec rake "sla:apply_to_conversations[19,1,500]"
+#
+#   # Using environment variables (recommended)
+#   SLA_POLICY_ID=19 ACCOUNT_ID=1 BATCH_SIZE=500 bundle exec rake sla:apply_to_conversations
+#
+# Parameters:
+#   SLA_POLICY_ID: ID of the SLA policy to apply (required)
+#   ACCOUNT_ID: ID of the account (required)
+#   BATCH_SIZE: Number of conversations to process (default: 1000)
+#
+# Notes:
+#   - Only runs in development environment
+#   - Processes conversations in order of newest first (id DESC)
+#   - Safe to run multiple times - skips conversations that already have SLA policies
+#   - Creates AppliedSla records automatically via Rails callbacks
+#   - SlaEvent records are created later by background jobs when violations occur
+#
+# rubocop:disable Metrics/BlockLength
+namespace :sla do
+  desc 'Apply SLA policy to existing conversations'
+  task :apply_to_conversations, [:sla_policy_id, :account_id, :batch_size] => :environment do |_t, args|
+    unless Rails.env.development?
+      puts 'This task can only be run in the development environment.'
+      puts "Current environment: #{Rails.env}"
+      exit(1)
+    end
+
+    sla_policy_id = args[:sla_policy_id] || ENV.fetch('SLA_POLICY_ID', nil)
+    account_id = args[:account_id] || ENV.fetch('ACCOUNT_ID', nil)
+    batch_size = (args[:batch_size] || ENV['BATCH_SIZE'] || 1000).to_i
+
+    if sla_policy_id.blank?
+      puts 'Error: SLA_POLICY_ID is required'
+      puts 'Usage: bundle exec rake sla:apply_to_conversations[sla_policy_id,account_id,batch_size]'
+      puts 'Or: SLA_POLICY_ID=1 ACCOUNT_ID=1 BATCH_SIZE=500 bundle exec rake sla:apply_to_conversations'
+      exit(1)
+    end
+
+    if account_id.blank?
+      puts 'Error: ACCOUNT_ID is required'
+      puts 'Usage: bundle exec rake sla:apply_to_conversations[sla_policy_id,account_id,batch_size]'
+      puts 'Or: SLA_POLICY_ID=1 ACCOUNT_ID=1 BATCH_SIZE=500 bundle exec rake sla:apply_to_conversations'
+      exit(1)
+    end
+
+    account = Account.find_by(id: account_id)
+    unless account
+      puts "Error: Account with ID #{account_id} not found"
+      exit(1)
+    end
+
+    sla_policy = account.sla_policies.find_by(id: sla_policy_id)
+    unless sla_policy
+      puts "Error: SLA Policy with ID #{sla_policy_id} not found for Account #{account_id}"
+      exit(1)
+    end
+
+    conversations = account.conversations.where(sla_policy_id: nil).order(id: :desc).limit(batch_size)
+    total_count = conversations.count
+
+    if total_count.zero?
+      puts 'No conversations found without SLA policy'
+      exit(0)
+    end
+
+    puts "Applying SLA Policy '#{sla_policy.name}' (ID: #{sla_policy_id}) to #{total_count} conversations in Account #{account_id}"
+    puts "Processing in batches of #{batch_size}"
+    puts "Started at: #{Time.current}"
+
+    start_time = Time.current
+    processed_count = 0
+    error_count = 0
+
+    conversations.find_in_batches(batch_size: batch_size) do |batch|
+      batch.each do |conversation|
+        conversation.update!(sla_policy_id: sla_policy_id)
+        processed_count += 1
+        puts "Processed #{processed_count}/#{total_count} conversations" if (processed_count % 100).zero?
+      rescue StandardError => e
+        error_count += 1
+        puts "Error applying SLA to conversation #{conversation.id}: #{e.message}"
+      end
+    end
+
+    elapsed_time = Time.current - start_time
+    puts "\nCompleted!"
+    puts "Successfully processed: #{processed_count} conversations"
+    puts "Errors encountered: #{error_count}" if error_count.positive?
+    puts "Total time: #{elapsed_time.round(2)}s"
+    puts "Average time per conversation: #{(elapsed_time / processed_count).round(3)}s" if processed_count.positive?
+  end
+end
+# rubocop:enable Metrics/BlockLength
diff --git a/lib/tasks/auto_annotate_models.rake b/lib/tasks/auto_annotate_models.rake
index 8a89739b6..9dcd13126 100644
--- a/lib/tasks/auto_annotate_models.rake
+++ b/lib/tasks/auto_annotate_models.rake
@@ -2,11 +2,14 @@
 # NOTE: are sensitive to local FS writes, and besides -- it's just not proper
 # NOTE: to have a dev-mode tool do its thing in production.
 if Rails.env.development?
-  require 'annotate'
+  require 'annotate_rb'
+
+  AnnotateRb::Core.load_rake_tasks
+
   task :set_annotation_options do
     # You can override any of these by setting an environment variable of the
     # same name.
-    Annotate.set_defaults(
+    AnnotateRb::Options.set_defaults(
       'additional_file_patterns' => [],
       'routes' => 'false',
       'models' => 'true',
@@ -55,6 +58,4 @@ if Rails.env.development?
       'with_comment' => 'true'
     )
   end
-
-  Annotate.load_tasks
 end
diff --git a/lib/tasks/bulk_conversations.rake b/lib/tasks/bulk_conversations.rake
new file mode 100644
index 000000000..e17851f31
--- /dev/null
+++ b/lib/tasks/bulk_conversations.rake
@@ -0,0 +1,176 @@
+# Generate Bulk Conversations
+#
+# This task creates bulk conversations with fake contacts and movie dialogue messages
+# for testing purposes. Each conversation gets random messages between contacts and agents.
+#
+# Usage Examples:
+#   # Using arguments (may need escaping in some shells)
+#   bundle exec rake "conversations:generate_bulk[100,1,1]"
+#
+#   # Using environment variables (recommended)
+#   COUNT=100 ACCOUNT_ID=1 INBOX_ID=1 bundle exec rake conversations:generate_bulk
+#
+#   # Generate 50 conversations
+#   COUNT=50 ACCOUNT_ID=1 INBOX_ID=1 bundle exec rake conversations:generate_bulk
+#
+# Parameters:
+#   COUNT: Number of conversations to create (default: 10)
+#   ACCOUNT_ID: ID of the account (required)
+#   INBOX_ID: ID of the inbox that belongs to the account (required)
+#
+# What it creates:
+#   - Unique contacts with fake names, emails, phone numbers
+#   - Conversations with random status (open/resolved/pending)
+#   - 3-10 messages per conversation with movie quotes
+#   - Alternating incoming/outgoing message flow
+#
+# Notes:
+#   - Only runs in development environment
+#   - Creates realistic test data for conversation testing
+#   - Progress shown every 10 conversations
+#   - All contacts get unique email addresses to avoid conflicts
+#
+# rubocop:disable Metrics/BlockLength
+namespace :conversations do
+  desc 'Generate bulk conversations with contacts and movie dialogue messages'
+  task :generate_bulk, [:count, :account_id, :inbox_id] => :environment do |_t, args|
+    unless Rails.env.development?
+      puts 'This task can only be run in the development environment.'
+      puts "Current environment: #{Rails.env}"
+      exit(1)
+    end
+
+    count = (args[:count] || ENV['COUNT'] || 10).to_i
+    account_id = args[:account_id] || ENV.fetch('ACCOUNT_ID', nil)
+    inbox_id = args[:inbox_id] || ENV.fetch('INBOX_ID', nil)
+
+    if account_id.blank?
+      puts 'Error: ACCOUNT_ID is required'
+      puts 'Usage: bundle exec rake conversations:generate_bulk[count,account_id,inbox_id]'
+      puts 'Or: COUNT=100 ACCOUNT_ID=1 INBOX_ID=1 bundle exec rake conversations:generate_bulk'
+      exit(1)
+    end
+
+    if inbox_id.blank?
+      puts 'Error: INBOX_ID is required'
+      puts 'Usage: bundle exec rake conversations:generate_bulk[count,account_id,inbox_id]'
+      puts 'Or: COUNT=100 ACCOUNT_ID=1 INBOX_ID=1 bundle exec rake conversations:generate_bulk'
+      exit(1)
+    end
+
+    account = Account.find_by(id: account_id)
+    inbox = Inbox.find_by(id: inbox_id)
+
+    unless account
+      puts "Error: Account with ID #{account_id} not found"
+      exit(1)
+    end
+
+    unless inbox
+      puts "Error: Inbox with ID #{inbox_id} not found"
+      exit(1)
+    end
+
+    unless inbox.account_id == account.id
+      puts "Error: Inbox #{inbox_id} does not belong to Account #{account_id}"
+      exit(1)
+    end
+
+    puts "Generating #{count} conversations for Account ##{account.id} in Inbox ##{inbox.id}..."
+    puts "Started at: #{Time.current}"
+
+    start_time = Time.current
+    created_count = 0
+
+    count.times do |i|
+      contact = create_contact(account)
+      contact_inbox = create_contact_inbox(contact, inbox)
+      conversation = create_conversation(contact_inbox)
+      add_messages(conversation)
+
+      created_count += 1
+      puts "Created conversation #{i + 1}/#{count} (ID: #{conversation.id})" if ((i + 1) % 10).zero?
+    rescue StandardError => e
+      puts "Error creating conversation #{i + 1}: #{e.message}"
+      puts e.backtrace.first(5).join("\n")
+    end
+
+    elapsed_time = Time.current - start_time
+    puts "\nCompleted!"
+    puts "Successfully created: #{created_count} conversations"
+    puts "Total time: #{elapsed_time.round(2)}s"
+    puts "Average time per conversation: #{(elapsed_time / created_count).round(3)}s" if created_count.positive?
+  end
+
+  def create_contact(account)
+    Contact.create!(
+      account: account,
+      name: Faker::Name.name,
+      email: "#{SecureRandom.uuid}@example.com",
+      phone_number: generate_e164_phone_number,
+      additional_attributes: {
+        source: 'bulk_generator',
+        company: Faker::Company.name,
+        city: Faker::Address.city
+      }
+    )
+  end
+
+  def generate_e164_phone_number
+    country_code = [1, 44, 61, 91, 81].sample
+    subscriber_number = rand(1_000_000..9_999_999_999).to_s
+    subscriber_number = subscriber_number[0...(15 - country_code.to_s.length)]
+    "+#{country_code}#{subscriber_number}"
+  end
+
+  def create_contact_inbox(contact, inbox)
+    ContactInboxBuilder.new(
+      contact: contact,
+      inbox: inbox
+    ).perform
+  end
+
+  def create_conversation(contact_inbox)
+    ConversationBuilder.new(
+      params: ActionController::Parameters.new(
+        status: %w[open resolved pending].sample,
+        additional_attributes: {},
+        custom_attributes: {}
+      ),
+      contact_inbox: contact_inbox
+    ).perform
+  end
+
+  def add_messages(conversation)
+    num_messages = rand(3..10)
+    message_type = %w[incoming outgoing].sample
+
+    num_messages.times do
+      message_type = message_type == 'incoming' ? 'outgoing' : 'incoming'
+      create_message(conversation, message_type)
+    end
+  end
+
+  def create_message(conversation, message_type)
+    sender = if message_type == 'incoming'
+               conversation.contact
+             else
+               conversation.account.users.sample || conversation.account.administrators.first
+             end
+
+    conversation.messages.create!(
+      account: conversation.account,
+      inbox: conversation.inbox,
+      sender: sender,
+      message_type: message_type,
+      content: generate_movie_dialogue,
+      content_type: :text,
+      private: false
+    )
+  end
+
+  def generate_movie_dialogue
+    Faker::Movie.quote
+  end
+end
+# rubocop:enable Metrics/BlockLength
diff --git a/package.json b/package.json
index 406e83b13..84c266880 100644
--- a/package.json
+++ b/package.json
@@ -33,7 +33,7 @@
   "dependencies": {
     "@breezystack/lamejs": "^1.2.7",
     "@chatwoot/ninja-keys": "1.2.3",
-    "@chatwoot/prosemirror-schema": "1.2.3",
+    "@chatwoot/prosemirror-schema": "1.2.6",
     "@chatwoot/utils": "^0.0.51",
     "@formkit/core": "^1.6.7",
     "@formkit/vue": "^1.6.7",
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 65dacb287..602a3c5c7 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -20,8 +20,8 @@ importers:
         specifier: 1.2.3
         version: 1.2.3
       '@chatwoot/prosemirror-schema':
-        specifier: 1.2.3
-        version: 1.2.3
+        specifier: 1.2.6
+        version: 1.2.6
       '@chatwoot/utils':
         specifier: ^0.0.51
         version: 0.0.51
@@ -421,8 +421,8 @@ packages:
   '@chatwoot/ninja-keys@1.2.3':
     resolution: {integrity: sha512-xM8d9P5ikDMZm2WbaCTk/TW5HFauylrU3cJ75fq5je6ixKwyhl/0kZbVN/vbbZN4+AUX/OaSIn6IJbtCgIF67g==}
 
-  '@chatwoot/prosemirror-schema@1.2.3':
-    resolution: {integrity: sha512-q/EfirVK9jt8FJAx3Gf6y3LoVadmYVLknbYvPrkUe81WO0f2mkZ/kY2UQgpUISVvOGEkCH4bkfYMp5UQ+Buz3g==}
+  '@chatwoot/prosemirror-schema@1.2.6':
+    resolution: {integrity: sha512-ej60kU3m/tP0VoGkOJhj0X+Mxt7fEX5DSEE4IibCZnTM4kMewkMxSYyPu0AXqaA4nKX1hTMrwcbv1t7gVQttWQ==}
 
   '@chatwoot/utils@0.0.51':
     resolution: {integrity: sha512-WlEmWfOTzR7YZRUWzn5Wpm15/BRudpwqoNckph8TohyDbiim1CP4UZGa+qjajxTbNGLLhtKlm0Xl+X16+5Wceg==}
@@ -4862,7 +4862,7 @@ snapshots:
       hotkeys-js: 3.8.7
       lit: 2.2.6
 
-  '@chatwoot/prosemirror-schema@1.2.3':
+  '@chatwoot/prosemirror-schema@1.2.6':
     dependencies:
       markdown-it-sup: 2.0.0
       prosemirror-commands: 1.6.0
diff --git a/spec/controllers/api/v1/accounts/inbox_csat_templates_controller_spec.rb b/spec/controllers/api/v1/accounts/inbox_csat_templates_controller_spec.rb
new file mode 100644
index 000000000..7ca9083c0
--- /dev/null
+++ b/spec/controllers/api/v1/accounts/inbox_csat_templates_controller_spec.rb
@@ -0,0 +1,383 @@
+require 'rails_helper'
+
+RSpec.describe Api::V1::Accounts::InboxCsatTemplatesController, type: :request do
+  let(:account) { create(:account) }
+  let(:admin) { create(:user, account: account, role: :administrator) }
+  let(:agent) { create(:user, account: account, role: :agent) }
+  let(:whatsapp_channel) do
+    create(:channel_whatsapp, account: account, provider: 'whatsapp_cloud', sync_templates: false, validate_provider_config: false)
+  end
+  let(:whatsapp_inbox) { create(:inbox, channel: whatsapp_channel, account: account) }
+  let(:web_widget_inbox) { create(:inbox, account: account) }
+  let(:mock_service) { instance_double(Whatsapp::Providers::WhatsappCloudService) }
+
+  before do
+    create(:inbox_member, user: agent, inbox: whatsapp_inbox)
+    allow(Whatsapp::Providers::WhatsappCloudService).to receive(:new).and_return(mock_service)
+  end
+
+  describe 'GET /api/v1/accounts/{account.id}/inboxes/{inbox.id}/csat_template' do
+    context 'when it is an unauthenticated user' do
+      it 'returns unauthorized' do
+        get "/api/v1/accounts/#{account.id}/inboxes/#{whatsapp_inbox.id}/csat_template"
+
+        expect(response).to have_http_status(:unauthorized)
+      end
+    end
+
+    context 'when it is not a WhatsApp channel' do
+      it 'returns bad request' do
+        get "/api/v1/accounts/#{account.id}/inboxes/#{web_widget_inbox.id}/csat_template",
+            headers: admin.create_new_auth_token,
+            as: :json
+
+        expect(response).to have_http_status(:bad_request)
+        expect(response.parsed_body['error']).to eq('CSAT template operations only available for WhatsApp channels')
+      end
+    end
+
+    context 'when it is a WhatsApp channel' do
+      it 'returns template not found when no configuration exists' do
+        get "/api/v1/accounts/#{account.id}/inboxes/#{whatsapp_inbox.id}/csat_template",
+            headers: admin.create_new_auth_token,
+            as: :json
+
+        expect(response).to have_http_status(:success)
+        expect(response.parsed_body['template_exists']).to be false
+      end
+
+      it 'returns template status when template exists on WhatsApp' do
+        template_config = {
+          'template' => {
+            'name' => 'custom_survey_template',
+            'template_id' => '123456789',
+            'language' => 'en'
+          }
+        }
+        whatsapp_inbox.update!(csat_config: template_config)
+
+        allow(mock_service).to receive(:get_template_status)
+          .with('custom_survey_template')
+          .and_return({
+                        success: true,
+                        template: { id: '123456789', status: 'APPROVED' }
+                      })
+
+        get "/api/v1/accounts/#{account.id}/inboxes/#{whatsapp_inbox.id}/csat_template",
+            headers: admin.create_new_auth_token,
+            as: :json
+
+        expect(response).to have_http_status(:success)
+        response_data = response.parsed_body
+        expect(response_data['template_exists']).to be true
+        expect(response_data['template_name']).to eq('custom_survey_template')
+        expect(response_data['status']).to eq('APPROVED')
+        expect(response_data['template_id']).to eq('123456789')
+      end
+
+      it 'returns template not found when template does not exist on WhatsApp' do
+        template_config = { 'template' => { 'name' => 'custom_survey_template' } }
+        whatsapp_inbox.update!(csat_config: template_config)
+
+        allow(mock_service).to receive(:get_template_status)
+          .with('custom_survey_template')
+          .and_return({ success: false, error: 'Template not found' })
+
+        get "/api/v1/accounts/#{account.id}/inboxes/#{whatsapp_inbox.id}/csat_template",
+            headers: admin.create_new_auth_token,
+            as: :json
+
+        expect(response).to have_http_status(:success)
+        response_data = response.parsed_body
+        expect(response_data['template_exists']).to be false
+        expect(response_data['error']).to eq('Template not found')
+      end
+
+      it 'handles service errors gracefully' do
+        template_config = { 'template' => { 'name' => 'custom_survey_template' } }
+        whatsapp_inbox.update!(csat_config: template_config)
+
+        allow(mock_service).to receive(:get_template_status)
+          .and_raise(StandardError, 'API connection failed')
+
+        get "/api/v1/accounts/#{account.id}/inboxes/#{whatsapp_inbox.id}/csat_template",
+            headers: admin.create_new_auth_token,
+            as: :json
+
+        expect(response).to have_http_status(:internal_server_error)
+        expect(response.parsed_body['error']).to eq('API connection failed')
+      end
+
+      it 'returns unauthorized when agent is not assigned to inbox' do
+        other_agent = create(:user, account: account, role: :agent)
+
+        get "/api/v1/accounts/#{account.id}/inboxes/#{whatsapp_inbox.id}/csat_template",
+            headers: other_agent.create_new_auth_token,
+            as: :json
+
+        expect(response).to have_http_status(:unauthorized)
+      end
+
+      it 'allows access when agent is assigned to inbox' do
+        whatsapp_inbox.update!(csat_config: { 'template' => { 'name' => 'test' } })
+        allow(mock_service).to receive(:get_template_status)
+          .and_return({ success: true, template: { id: '123', status: 'APPROVED' } })
+
+        get "/api/v1/accounts/#{account.id}/inboxes/#{whatsapp_inbox.id}/csat_template",
+            headers: agent.create_new_auth_token,
+            as: :json
+
+        expect(response).to have_http_status(:success)
+      end
+    end
+  end
+
+  describe 'POST /api/v1/accounts/{account.id}/inboxes/{inbox.id}/csat_template' do
+    let(:valid_template_params) do
+      {
+        template: {
+          message: 'How would you rate your experience?',
+          button_text: 'Rate Us',
+          language: 'en'
+        }
+      }
+    end
+
+    context 'when it is an unauthenticated user' do
+      it 'returns unauthorized' do
+        post "/api/v1/accounts/#{account.id}/inboxes/#{whatsapp_inbox.id}/csat_template",
+             params: valid_template_params,
+             as: :json
+
+        expect(response).to have_http_status(:unauthorized)
+      end
+    end
+
+    context 'when it is not a WhatsApp channel' do
+      it 'returns bad request' do
+        post "/api/v1/accounts/#{account.id}/inboxes/#{web_widget_inbox.id}/csat_template",
+             headers: admin.create_new_auth_token,
+             params: valid_template_params,
+             as: :json
+
+        expect(response).to have_http_status(:bad_request)
+        expect(response.parsed_body['error']).to eq('CSAT template operations only available for WhatsApp channels')
+      end
+    end
+
+    context 'when it is a WhatsApp channel' do
+      it 'returns error when message is missing' do
+        invalid_params = {
+          template: {
+            button_text: 'Rate Us',
+            language: 'en'
+          }
+        }
+
+        post "/api/v1/accounts/#{account.id}/inboxes/#{whatsapp_inbox.id}/csat_template",
+             headers: admin.create_new_auth_token,
+             params: invalid_params,
+             as: :json
+
+        expect(response).to have_http_status(:unprocessable_entity)
+        expect(response.parsed_body['error']).to eq('Message is required')
+      end
+
+      it 'returns error when template parameters are completely missing' do
+        post "/api/v1/accounts/#{account.id}/inboxes/#{whatsapp_inbox.id}/csat_template",
+             headers: admin.create_new_auth_token,
+             params: {},
+             as: :json
+
+        expect(response).to have_http_status(:unprocessable_entity)
+        expect(response.parsed_body['error']).to eq('Template parameters are required')
+      end
+
+      it 'creates template successfully' do
+        allow(mock_service).to receive(:get_template_status).and_return({ success: false })
+        allow(mock_service).to receive(:create_csat_template).and_return({
+                                                                           success: true,
+                                                                           template_name: "customer_satisfaction_survey_#{whatsapp_inbox.id}",
+                                                                           template_id: '987654321'
+                                                                         })
+
+        post "/api/v1/accounts/#{account.id}/inboxes/#{whatsapp_inbox.id}/csat_template",
+             headers: admin.create_new_auth_token,
+             params: valid_template_params,
+             as: :json
+
+        expect(response).to have_http_status(:created)
+        response_data = response.parsed_body
+        expect(response_data['template']['name']).to eq("customer_satisfaction_survey_#{whatsapp_inbox.id}")
+        expect(response_data['template']['template_id']).to eq('987654321')
+        expect(response_data['template']['status']).to eq('PENDING')
+        expect(response_data['template']['language']).to eq('en')
+      end
+
+      it 'uses default values for optional parameters' do
+        minimal_params = {
+          template: {
+            message: 'How would you rate your experience?'
+          }
+        }
+
+        allow(mock_service).to receive(:get_template_status).and_return({ success: false })
+        expect(mock_service).to receive(:create_csat_template) do |config|
+          expect(config[:button_text]).to eq('Please rate us')
+          expect(config[:language]).to eq('en')
+          expect(config[:template_name]).to eq("customer_satisfaction_survey_#{whatsapp_inbox.id}")
+          { success: true, template_name: "customer_satisfaction_survey_#{whatsapp_inbox.id}", template_id: '123' }
+        end
+
+        post "/api/v1/accounts/#{account.id}/inboxes/#{whatsapp_inbox.id}/csat_template",
+             headers: admin.create_new_auth_token,
+             params: minimal_params,
+             as: :json
+
+        expect(response).to have_http_status(:created)
+      end
+
+      it 'handles WhatsApp API errors with user-friendly messages' do
+        whatsapp_error_response = {
+          'error' => {
+            'code' => 100,
+            'error_subcode' => 2_388_092,
+            'message' => 'Invalid parameter',
+            'error_user_title' => 'Template Creation Failed',
+            'error_user_msg' => 'The template message contains invalid content. Please review your message and try again.'
+          }
+        }
+
+        allow(mock_service).to receive(:get_template_status).and_return({ success: false })
+        allow(mock_service).to receive(:create_csat_template).and_return({
+                                                                           success: false,
+                                                                           error: 'Template creation failed',
+                                                                           response_body: whatsapp_error_response.to_json
+                                                                         })
+
+        post "/api/v1/accounts/#{account.id}/inboxes/#{whatsapp_inbox.id}/csat_template",
+             headers: admin.create_new_auth_token,
+             params: valid_template_params,
+             as: :json
+
+        expect(response).to have_http_status(:unprocessable_entity)
+        response_data = response.parsed_body
+        expect(response_data['error']).to eq('The template message contains invalid content. Please review your message and try again.')
+        expect(response_data['details']).to include({
+                                                      'code' => 100,
+                                                      'subcode' => 2_388_092,
+                                                      'title' => 'Template Creation Failed'
+                                                    })
+      end
+
+      it 'handles generic API errors' do
+        allow(mock_service).to receive(:get_template_status).and_return({ success: false })
+        allow(mock_service).to receive(:create_csat_template).and_return({
+                                                                           success: false,
+                                                                           error: 'Network timeout',
+                                                                           response_body: nil
+                                                                         })
+
+        post "/api/v1/accounts/#{account.id}/inboxes/#{whatsapp_inbox.id}/csat_template",
+             headers: admin.create_new_auth_token,
+             params: valid_template_params,
+             as: :json
+
+        expect(response).to have_http_status(:unprocessable_entity)
+        expect(response.parsed_body['error']).to eq('Network timeout')
+      end
+
+      it 'handles unexpected service errors' do
+        allow(mock_service).to receive(:get_template_status).and_return({ success: false })
+        allow(mock_service).to receive(:create_csat_template)
+          .and_raise(StandardError, 'Unexpected error')
+
+        post "/api/v1/accounts/#{account.id}/inboxes/#{whatsapp_inbox.id}/csat_template",
+             headers: admin.create_new_auth_token,
+             params: valid_template_params,
+             as: :json
+
+        expect(response).to have_http_status(:internal_server_error)
+        expect(response.parsed_body['error']).to eq('Template creation failed')
+      end
+
+      it 'deletes existing template before creating new one' do
+        whatsapp_inbox.update!(csat_config: {
+                                 'template' => {
+                                   'name' => 'existing_template',
+                                   'template_id' => '111111111'
+                                 }
+                               })
+
+        allow(mock_service).to receive(:get_template_status)
+          .with('existing_template')
+          .and_return({ success: true, template: { id: '111111111' } })
+        expect(mock_service).to receive(:delete_csat_template)
+          .with('existing_template')
+          .and_return({ success: true })
+        expect(mock_service).to receive(:create_csat_template)
+          .and_return({
+                        success: true,
+                        template_name: "customer_satisfaction_survey_#{whatsapp_inbox.id}",
+                        template_id: '222222222'
+                      })
+
+        post "/api/v1/accounts/#{account.id}/inboxes/#{whatsapp_inbox.id}/csat_template",
+             headers: admin.create_new_auth_token,
+             params: valid_template_params,
+             as: :json
+
+        expect(response).to have_http_status(:created)
+      end
+
+      it 'continues with creation even if deletion fails' do
+        whatsapp_inbox.update!(csat_config: {
+                                 'template' => { 'name' => 'existing_template' }
+                               })
+
+        allow(mock_service).to receive(:get_template_status).and_return({ success: true })
+        allow(mock_service).to receive(:delete_csat_template)
+          .and_return({ success: false, response_body: 'Delete failed' })
+        allow(mock_service).to receive(:create_csat_template).and_return({
+                                                                           success: true,
+                                                                           template_name: "customer_satisfaction_survey_#{whatsapp_inbox.id}",
+                                                                           template_id: '333333333'
+                                                                         })
+
+        post "/api/v1/accounts/#{account.id}/inboxes/#{whatsapp_inbox.id}/csat_template",
+             headers: admin.create_new_auth_token,
+             params: valid_template_params,
+             as: :json
+
+        expect(response).to have_http_status(:created)
+      end
+
+      it 'returns unauthorized when agent is not assigned to inbox' do
+        other_agent = create(:user, account: account, role: :agent)
+
+        post "/api/v1/accounts/#{account.id}/inboxes/#{whatsapp_inbox.id}/csat_template",
+             headers: other_agent.create_new_auth_token,
+             params: valid_template_params,
+             as: :json
+
+        expect(response).to have_http_status(:unauthorized)
+      end
+
+      it 'allows access when agent is assigned to inbox' do
+        allow(mock_service).to receive(:get_template_status).and_return({ success: false })
+        allow(mock_service).to receive(:create_csat_template).and_return({
+                                                                           success: true,
+                                                                           template_name: 'customer_satisfaction_survey',
+                                                                           template_id: '444444444'
+                                                                         })
+
+        post "/api/v1/accounts/#{account.id}/inboxes/#{whatsapp_inbox.id}/csat_template",
+             headers: agent.create_new_auth_token,
+             params: valid_template_params,
+             as: :json
+
+        expect(response).to have_http_status(:created)
+      end
+    end
+  end
+end
diff --git a/spec/controllers/api/v1/accounts/inboxes_controller_spec.rb b/spec/controllers/api/v1/accounts/inboxes_controller_spec.rb
index a44f60391..fafd6788e 100644
--- a/spec/controllers/api/v1/accounts/inboxes_controller_spec.rb
+++ b/spec/controllers/api/v1/accounts/inboxes_controller_spec.rb
@@ -804,6 +804,101 @@ RSpec.describe 'Inboxes API', type: :request do
           expect(found_inbox['csat_config']['display_type']).to eq('emoji')
         end
       end
+
+      it 'successfully updates inbox with template configuration' do
+        csat_config_with_template = csat_config.merge({
+                                                        'template' => {
+                                                          'name' => 'custom_survey_template',
+                                                          'template_id' => '123456789',
+                                                          'language' => 'en',
+                                                          'created_at' => Time.current.iso8601
+                                                        }
+                                                      })
+
+        patch "/api/v1/accounts/#{account.id}/inboxes/#{inbox.id}",
+              params: {
+                csat_survey_enabled: true,
+                csat_config: csat_config_with_template
+              },
+              headers: admin.create_new_auth_token,
+              as: :json
+
+        expect(response).to have_http_status(:success)
+
+        inbox.reload
+        template_config = inbox.csat_config['template']
+        expect(template_config).to be_present
+        expect(template_config['name']).to eq('custom_survey_template')
+        expect(template_config['template_id']).to eq('123456789')
+        expect(template_config['language']).to eq('en')
+      end
+
+      it 'returns template configuration in inbox details' do
+        csat_config_with_template = csat_config.merge({
+                                                        'template' => {
+                                                          'name' => 'custom_survey_template',
+                                                          'template_id' => '123456789',
+                                                          'language' => 'en',
+                                                          'created_at' => Time.current.iso8601
+                                                        }
+                                                      })
+
+        patch "/api/v1/accounts/#{account.id}/inboxes/#{inbox.id}",
+              params: {
+                csat_survey_enabled: true,
+                csat_config: csat_config_with_template
+              },
+              headers: admin.create_new_auth_token,
+              as: :json
+
+        get "/api/v1/accounts/#{account.id}/inboxes/#{inbox.id}",
+            headers: admin.create_new_auth_token,
+            as: :json
+
+        expect(response).to have_http_status(:success)
+        json_response = response.parsed_body
+        template_config = json_response['csat_config']['template']
+
+        expect(template_config).to be_present
+        expect(template_config['name']).to eq('custom_survey_template')
+        expect(template_config['template_id']).to eq('123456789')
+        expect(template_config['language']).to eq('en')
+        expect(template_config['created_at']).to be_present
+      end
+
+      it 'removes template configuration when not provided in update' do
+        # First set up template configuration
+        csat_config_with_template = csat_config.merge({
+                                                        'template' => {
+                                                          'name' => 'custom_survey_template',
+                                                          'template_id' => '123456789'
+                                                        }
+                                                      })
+
+        patch "/api/v1/accounts/#{account.id}/inboxes/#{inbox.id}",
+              params: {
+                csat_survey_enabled: true,
+                csat_config: csat_config_with_template
+              },
+              headers: admin.create_new_auth_token,
+              as: :json
+
+        # Then update without template
+        patch "/api/v1/accounts/#{account.id}/inboxes/#{inbox.id}",
+              params: {
+                csat_survey_enabled: true,
+                csat_config: csat_config.merge({ 'message' => 'Updated message' })
+              },
+              headers: admin.create_new_auth_token,
+              as: :json
+
+        expect(response).to have_http_status(:success)
+
+        inbox.reload
+        config = inbox.csat_config
+        expect(config['message']).to eq('Updated message')
+        expect(config['template']).to be_nil # Template should be removed when not provided
+      end
     end
   end
 
diff --git a/spec/controllers/linear/callbacks_controller_spec.rb b/spec/controllers/linear/callbacks_controller_spec.rb
index b3245fbc5..66018776c 100644
--- a/spec/controllers/linear/callbacks_controller_spec.rb
+++ b/spec/controllers/linear/callbacks_controller_spec.rb
@@ -3,7 +3,8 @@ require 'rails_helper'
 RSpec.describe Linear::CallbacksController, type: :request do
   let(:account) { create(:account) }
   let(:code) { SecureRandom.hex(10) }
-  let(:state) { SecureRandom.hex(10) }
+  let(:client_secret) { 'test_linear_secret' }
+  let(:state) { JWT.encode({ sub: account.id, iat: Time.current.to_i }, client_secret, 'HS256') }
   let(:linear_redirect_uri) { "#{ENV.fetch('FRONTEND_URL', '')}/app/accounts/#{account.id}/settings/integrations/linear" }
 
   describe 'GET /linear/callback' do
@@ -19,10 +20,9 @@ RSpec.describe Linear::CallbacksController, type: :request do
 
     before do
       stub_const('ENV', ENV.to_hash.merge('FRONTEND_URL' => 'http://www.example.com'))
-
-      controller = described_class.new
-      allow(controller).to receive(:verify_linear_token).with(state).and_return(account.id)
-      allow(described_class).to receive(:new).and_return(controller)
+      allow(GlobalConfigService).to receive(:load).and_call_original
+      allow(GlobalConfigService).to receive(:load).with('LINEAR_CLIENT_SECRET', nil).and_return(client_secret)
+      allow(GlobalConfigService).to receive(:load).with('LINEAR_CLIENT_ID', nil).and_return('test_client_id')
     end
 
     context 'when successful' do
diff --git a/spec/enterprise/controllers/api/v1/accounts/sla_policies_controller_spec.rb b/spec/enterprise/controllers/api/v1/accounts/sla_policies_controller_spec.rb
index b1619ef85..e1a4fa538 100644
--- a/spec/enterprise/controllers/api/v1/accounts/sla_policies_controller_spec.rb
+++ b/spec/enterprise/controllers/api/v1/accounts/sla_policies_controller_spec.rb
@@ -161,12 +161,13 @@ RSpec.describe 'Enterprise SLA API', type: :request do
     let(:sla_policy) { create(:sla_policy, account: account) }
 
     context 'when it is an authenticated user' do
-      it 'deletes the sla_policy' do
+      it 'queues the sla_policy for deletion' do
+        expect(DeleteObjectJob).to receive(:perform_later).with(sla_policy, administrator, kind_of(String))
+
         delete "/api/v1/accounts/#{account.id}/sla_policies/#{sla_policy.id}",
                headers: administrator.create_new_auth_token
 
         expect(response).to have_http_status(:success)
-        expect(SlaPolicy.count).to eq(1)
       end
     end
 
diff --git a/spec/enterprise/jobs/captain/conversation/response_builder_job_spec.rb b/spec/enterprise/jobs/captain/conversation/response_builder_job_spec.rb
index 565fc26cf..08a77626a 100644
--- a/spec/enterprise/jobs/captain/conversation/response_builder_job_spec.rb
+++ b/spec/enterprise/jobs/captain/conversation/response_builder_job_spec.rb
@@ -229,4 +229,106 @@ RSpec.describe Captain::Conversation::ResponseBuilderJob, type: :job do
       expect(described_class::MAX_MESSAGE_LENGTH).to eq(10_000)
     end
   end
+
+  describe 'out of office message after handoff' do
+    let(:conversation) { create(:conversation, inbox: inbox, account: account, status: :pending) }
+    let(:mock_llm_chat_service) { instance_double(Captain::Llm::AssistantChatService) }
+
+    before do
+      create(:message, conversation: conversation, content: 'Hello', message_type: :incoming)
+      allow(Captain::Llm::AssistantChatService).to receive(:new).and_return(mock_llm_chat_service)
+      allow(account).to receive(:feature_enabled?).and_return(false)
+      allow(account).to receive(:feature_enabled?).with('captain_integration_v2').and_return(false)
+    end
+
+    context 'when handoff occurs outside business hours' do
+      before do
+        inbox.update!(
+          working_hours_enabled: true,
+          out_of_office_message: 'We are currently closed. Please leave your email.'
+        )
+        inbox.working_hours.find_by(day_of_week: Time.current.in_time_zone(inbox.timezone).wday).update!(
+          closed_all_day: true,
+          open_all_day: false
+        )
+        allow(mock_llm_chat_service).to receive(:generate_response).and_return({ 'response' => 'conversation_handoff' })
+      end
+
+      it 'sends out of office message after handoff' do
+        expect do
+          described_class.perform_now(conversation, assistant)
+        end.to change { conversation.messages.template.count }.by(1)
+
+        expect(conversation.reload.status).to eq('open')
+        ooo_message = conversation.messages.template.last
+        expect(ooo_message.content).to eq('We are currently closed. Please leave your email.')
+      end
+    end
+
+    context 'when handoff occurs within business hours' do
+      before do
+        inbox.update!(
+          working_hours_enabled: true,
+          out_of_office_message: 'We are currently closed.'
+        )
+        inbox.working_hours.find_by(day_of_week: Time.current.in_time_zone(inbox.timezone).wday).update!(
+          open_all_day: true,
+          closed_all_day: false
+        )
+        allow(mock_llm_chat_service).to receive(:generate_response).and_return({ 'response' => 'conversation_handoff' })
+      end
+
+      it 'does not send out of office message after handoff' do
+        expect do
+          described_class.perform_now(conversation, assistant)
+        end.not_to(change { conversation.messages.template.count })
+
+        expect(conversation.reload.status).to eq('open')
+      end
+    end
+
+    context 'when handoff occurs due to error outside business hours' do
+      before do
+        inbox.update!(
+          working_hours_enabled: true,
+          out_of_office_message: 'We are currently closed.'
+        )
+        inbox.working_hours.find_by(day_of_week: Time.current.in_time_zone(inbox.timezone).wday).update!(
+          closed_all_day: true,
+          open_all_day: false
+        )
+        allow(mock_llm_chat_service).to receive(:generate_response).and_raise(StandardError, 'API error')
+      end
+
+      it 'sends out of office message after error-triggered handoff' do
+        expect do
+          described_class.perform_now(conversation, assistant)
+        end.to change { conversation.messages.template.count }.by(1)
+
+        expect(conversation.reload.status).to eq('open')
+        ooo_message = conversation.messages.template.last
+        expect(ooo_message.content).to eq('We are currently closed.')
+      end
+    end
+
+    context 'when no out of office message is configured' do
+      before do
+        inbox.update!(
+          working_hours_enabled: true,
+          out_of_office_message: nil
+        )
+        inbox.working_hours.find_by(day_of_week: Time.current.in_time_zone(inbox.timezone).wday).update!(
+          closed_all_day: true,
+          open_all_day: false
+        )
+        allow(mock_llm_chat_service).to receive(:generate_response).and_return({ 'response' => 'conversation_handoff' })
+      end
+
+      it 'does not send out of office message' do
+        expect do
+          described_class.perform_now(conversation, assistant)
+        end.not_to(change { conversation.messages.template.count })
+      end
+    end
+  end
 end
diff --git a/spec/enterprise/jobs/captain/documents/response_builder_job_spec.rb b/spec/enterprise/jobs/captain/documents/response_builder_job_spec.rb
index 73b67ee27..c3e5eab1c 100644
--- a/spec/enterprise/jobs/captain/documents/response_builder_job_spec.rb
+++ b/spec/enterprise/jobs/captain/documents/response_builder_job_spec.rb
@@ -13,7 +13,7 @@ RSpec.describe Captain::Documents::ResponseBuilderJob, type: :job do
 
   before do
     allow(Captain::Llm::FaqGeneratorService).to receive(:new)
-      .with(document.content, document.account.locale_english_name)
+      .with(document.content, document.account.locale_english_name, account_id: document.account_id)
       .and_return(faq_generator)
     allow(faq_generator).to receive(:generate).and_return(faqs)
   end
@@ -52,7 +52,7 @@ RSpec.describe Captain::Documents::ResponseBuilderJob, type: :job do
 
       before do
         allow(Captain::Llm::FaqGeneratorService).to receive(:new)
-          .with(spanish_document.content, 'portuguese')
+          .with(spanish_document.content, 'portuguese', account_id: spanish_document.account_id)
           .and_return(spanish_faq_generator)
         allow(spanish_faq_generator).to receive(:generate).and_return(faqs)
       end
@@ -61,7 +61,7 @@ RSpec.describe Captain::Documents::ResponseBuilderJob, type: :job do
         described_class.new.perform(spanish_document)
 
         expect(Captain::Llm::FaqGeneratorService).to have_received(:new)
-          .with(spanish_document.content, 'portuguese')
+          .with(spanish_document.content, 'portuguese', account_id: spanish_document.account_id)
       end
     end
 
diff --git a/spec/enterprise/lib/captain/tools/handoff_tool_spec.rb b/spec/enterprise/lib/captain/tools/handoff_tool_spec.rb
index 16b46c08a..ef56ae3bb 100644
--- a/spec/enterprise/lib/captain/tools/handoff_tool_spec.rb
+++ b/spec/enterprise/lib/captain/tools/handoff_tool_spec.rb
@@ -163,4 +163,66 @@ RSpec.describe Captain::Tools::HandoffTool, type: :model do
       expect(tool.active?).to be true
     end
   end
+
+  describe 'out of office message after handoff' do
+    context 'when outside business hours' do
+      before do
+        inbox.update!(
+          working_hours_enabled: true,
+          out_of_office_message: 'We are currently closed. Please leave your email.'
+        )
+        inbox.working_hours.find_by(day_of_week: Time.current.in_time_zone(inbox.timezone).wday).update!(
+          closed_all_day: true,
+          open_all_day: false
+        )
+      end
+
+      it 'sends out of office message after handoff' do
+        expect do
+          tool.perform(tool_context, reason: 'Customer needs help')
+        end.to change { conversation.messages.template.count }.by(1)
+
+        ooo_message = conversation.messages.template.last
+        expect(ooo_message.content).to eq('We are currently closed. Please leave your email.')
+      end
+    end
+
+    context 'when within business hours' do
+      before do
+        inbox.update!(
+          working_hours_enabled: true,
+          out_of_office_message: 'We are currently closed.'
+        )
+        inbox.working_hours.find_by(day_of_week: Time.current.in_time_zone(inbox.timezone).wday).update!(
+          open_all_day: true,
+          closed_all_day: false
+        )
+      end
+
+      it 'does not send out of office message after handoff' do
+        expect do
+          tool.perform(tool_context, reason: 'Customer needs help')
+        end.not_to(change { conversation.messages.template.count })
+      end
+    end
+
+    context 'when no out of office message is configured' do
+      before do
+        inbox.update!(
+          working_hours_enabled: true,
+          out_of_office_message: nil
+        )
+        inbox.working_hours.find_by(day_of_week: Time.current.in_time_zone(inbox.timezone).wday).update!(
+          closed_all_day: true,
+          open_all_day: false
+        )
+      end
+
+      it 'does not send out of office message' do
+        expect do
+          tool.perform(tool_context, reason: 'Customer needs help')
+        end.not_to(change { conversation.messages.template.count })
+      end
+    end
+  end
 end
diff --git a/spec/enterprise/lib/captain/tools/http_tool_spec.rb b/spec/enterprise/lib/captain/tools/http_tool_spec.rb
index d48af2752..967a10574 100644
--- a/spec/enterprise/lib/captain/tools/http_tool_spec.rb
+++ b/spec/enterprise/lib/captain/tools/http_tool_spec.rb
@@ -237,5 +237,135 @@ RSpec.describe Captain::Tools::HttpTool, type: :model do
         expect(result).to eq('Created order #ORD-789 for Widget')
       end
     end
+
+    context 'with metadata headers' do
+      let(:conversation) { create(:conversation, account: account) }
+      let(:contact) { conversation.contact }
+      let(:tool_context_with_state) do
+        Struct.new(:state).new({
+                                 account_id: account.id,
+                                 assistant_id: assistant.id,
+                                 conversation: {
+                                   id: conversation.id,
+                                   display_id: conversation.display_id
+                                 },
+                                 contact: {
+                                   id: contact.id,
+                                   email: contact.email,
+                                   phone_number: contact.phone_number
+                                 }
+                               })
+      end
+
+      before do
+        custom_tool.update!(
+          endpoint_url: 'https://example.com/api/data',
+          response_template: nil
+        )
+      end
+
+      it 'includes metadata headers in GET request' do
+        stub_request(:get, 'https://example.com/api/data')
+          .with(headers: {
+                  'X-Chatwoot-Account-Id' => account.id.to_s,
+                  'X-Chatwoot-Assistant-Id' => assistant.id.to_s,
+                  'X-Chatwoot-Tool-Slug' => custom_tool.slug,
+                  'X-Chatwoot-Conversation-Id' => conversation.id.to_s,
+                  'X-Chatwoot-Conversation-Display-Id' => conversation.display_id.to_s,
+                  'X-Chatwoot-Contact-Id' => contact.id.to_s,
+                  'X-Chatwoot-Contact-Email' => contact.email
+                })
+          .to_return(status: 200, body: '{"success": true}')
+
+        tool.perform(tool_context_with_state)
+
+        expect(WebMock).to have_requested(:get, 'https://example.com/api/data')
+          .with(headers: {
+                  'X-Chatwoot-Account-Id' => account.id.to_s,
+                  'X-Chatwoot-Contact-Email' => contact.email
+                })
+      end
+
+      it 'includes metadata headers in POST request' do
+        custom_tool.update!(http_method: 'POST', request_template: '{"data": "test"}')
+
+        stub_request(:post, 'https://example.com/api/data')
+          .with(
+            body: '{"data": "test"}',
+            headers: {
+              'Content-Type' => 'application/json',
+              'X-Chatwoot-Account-Id' => account.id.to_s,
+              'X-Chatwoot-Tool-Slug' => custom_tool.slug,
+              'X-Chatwoot-Contact-Email' => contact.email
+            }
+          )
+          .to_return(status: 200, body: '{"success": true}')
+
+        tool.perform(tool_context_with_state)
+
+        expect(WebMock).to have_requested(:post, 'https://example.com/api/data')
+      end
+
+      it 'includes metadata headers along with authentication headers' do
+        custom_tool.update!(
+          auth_type: 'bearer',
+          auth_config: { 'token' => 'test_token' }
+        )
+
+        stub_request(:get, 'https://example.com/api/data')
+          .with(headers: {
+                  'Authorization' => 'Bearer test_token',
+                  'X-Chatwoot-Account-Id' => account.id.to_s,
+                  'X-Chatwoot-Contact-Id' => contact.id.to_s
+                })
+          .to_return(status: 200, body: '{"success": true}')
+
+        tool.perform(tool_context_with_state)
+
+        expect(WebMock).to have_requested(:get, 'https://example.com/api/data')
+          .with(headers: {
+                  'Authorization' => 'Bearer test_token',
+                  'X-Chatwoot-Contact-Id' => contact.id.to_s
+                })
+      end
+
+      it 'handles missing contact in tool context' do
+        tool_context_no_contact = Struct.new(:state).new({
+                                                           account_id: account.id,
+                                                           assistant_id: assistant.id,
+                                                           conversation: {
+                                                             id: conversation.id,
+                                                             display_id: conversation.display_id
+                                                           }
+                                                         })
+
+        stub_request(:get, 'https://example.com/api/data')
+          .with(headers: {
+                  'X-Chatwoot-Account-Id' => account.id.to_s,
+                  'X-Chatwoot-Conversation-Id' => conversation.id.to_s
+                })
+          .to_return(status: 200, body: '{"success": true}')
+
+        tool.perform(tool_context_no_contact)
+
+        expect(WebMock).to have_requested(:get, 'https://example.com/api/data')
+      end
+
+      it 'includes contact phone when present' do
+        contact.update!(phone_number: '+1234567890')
+        tool_context_with_state.state[:contact][:phone_number] = '+1234567890'
+
+        stub_request(:get, 'https://example.com/api/data')
+          .with(headers: {
+                  'X-Chatwoot-Contact-Phone' => '+1234567890'
+                })
+          .to_return(status: 200, body: '{"success": true}')
+
+        tool.perform(tool_context_with_state)
+
+        expect(WebMock).to have_requested(:get, 'https://example.com/api/data')
+          .with(headers: { 'X-Chatwoot-Contact-Phone' => '+1234567890' })
+      end
+    end
   end
 end
diff --git a/spec/enterprise/models/captain/custom_tool_spec.rb b/spec/enterprise/models/captain/custom_tool_spec.rb
index 5f6c7b19a..f936eeaa5 100644
--- a/spec/enterprise/models/captain/custom_tool_spec.rb
+++ b/spec/enterprise/models/captain/custom_tool_spec.rb
@@ -327,6 +327,98 @@ RSpec.describe Captain::CustomTool, type: :model do
       end
     end
 
+    describe '#build_metadata_headers' do
+      let(:tool) { create(:captain_custom_tool, account: account, slug: 'custom_test_tool') }
+      let(:conversation) { create(:conversation, account: account) }
+      let(:contact) { conversation.contact }
+
+      let(:state) do
+        {
+          account_id: account.id,
+          assistant_id: 123,
+          conversation: {
+            id: conversation.id,
+            display_id: conversation.display_id
+          },
+          contact: {
+            id: contact.id,
+            email: contact.email,
+            phone_number: contact.phone_number
+          }
+        }
+      end
+
+      it 'includes account and assistant metadata' do
+        headers = tool.build_metadata_headers(state)
+
+        expect(headers['X-Chatwoot-Account-Id']).to eq(account.id.to_s)
+        expect(headers['X-Chatwoot-Assistant-Id']).to eq('123')
+      end
+
+      it 'includes tool slug' do
+        headers = tool.build_metadata_headers(state)
+
+        expect(headers['X-Chatwoot-Tool-Slug']).to eq('custom_test_tool')
+      end
+
+      it 'includes conversation metadata when present' do
+        headers = tool.build_metadata_headers(state)
+
+        expect(headers['X-Chatwoot-Conversation-Id']).to eq(conversation.id.to_s)
+        expect(headers['X-Chatwoot-Conversation-Display-Id']).to eq(conversation.display_id.to_s)
+      end
+
+      it 'includes contact metadata when present' do
+        headers = tool.build_metadata_headers(state)
+
+        expect(headers['X-Chatwoot-Contact-Id']).to eq(contact.id.to_s)
+        expect(headers['X-Chatwoot-Contact-Email']).to eq(contact.email)
+      end
+
+      it 'handles missing conversation gracefully' do
+        state[:conversation] = nil
+
+        headers = tool.build_metadata_headers(state)
+
+        expect(headers['X-Chatwoot-Conversation-Id']).to be_nil
+        expect(headers['X-Chatwoot-Conversation-Display-Id']).to be_nil
+        expect(headers['X-Chatwoot-Account-Id']).to eq(account.id.to_s)
+      end
+
+      it 'handles missing contact gracefully' do
+        state[:contact] = nil
+
+        headers = tool.build_metadata_headers(state)
+
+        expect(headers['X-Chatwoot-Contact-Id']).to be_nil
+        expect(headers['X-Chatwoot-Contact-Email']).to be_nil
+        expect(headers['X-Chatwoot-Account-Id']).to eq(account.id.to_s)
+      end
+
+      it 'handles empty state' do
+        headers = tool.build_metadata_headers({})
+
+        expect(headers).to be_a(Hash)
+        expect(headers['X-Chatwoot-Tool-Slug']).to eq('custom_test_tool')
+      end
+
+      it 'omits contact email header when email is blank' do
+        state[:contact][:email] = ''
+
+        headers = tool.build_metadata_headers(state)
+
+        expect(headers).not_to have_key('X-Chatwoot-Contact-Email')
+      end
+
+      it 'omits contact phone header when phone number is blank' do
+        state[:contact][:phone_number] = ''
+
+        headers = tool.build_metadata_headers(state)
+
+        expect(headers).not_to have_key('X-Chatwoot-Contact-Phone')
+      end
+    end
+
     describe '#to_tool_metadata' do
       it 'returns tool metadata hash with custom flag' do
         tool = create(:captain_custom_tool, account: account,
diff --git a/spec/enterprise/services/captain/llm/conversation_faq_service_spec.rb b/spec/enterprise/services/captain/llm/conversation_faq_service_spec.rb
index ee993da37..0ab7f37bf 100644
--- a/spec/enterprise/services/captain/llm/conversation_faq_service_spec.rb
+++ b/spec/enterprise/services/captain/llm/conversation_faq_service_spec.rb
@@ -4,49 +4,42 @@ RSpec.describe Captain::Llm::ConversationFaqService do
   let(:captain_assistant) { create(:captain_assistant) }
   let(:conversation) { create(:conversation, first_reply_created_at: Time.zone.now) }
   let(:service) { described_class.new(captain_assistant, conversation) }
-  let(:client) { instance_double(OpenAI::Client) }
   let(:embedding_service) { instance_double(Captain::Llm::EmbeddingService) }
+  let(:mock_chat) { instance_double(RubyLLM::Chat) }
+  let(:sample_faqs) do
+    [
+      { 'question' => 'What is the purpose?', 'answer' => 'To help users.' },
+      { 'question' => 'How does it work?', 'answer' => 'Through AI.' }
+    ]
+  end
+  let(:mock_response) do
+    instance_double(RubyLLM::Message, content: { faqs: sample_faqs }.to_json)
+  end
 
   before do
-    create(:installation_config) { create(:installation_config, name: 'CAPTAIN_OPEN_AI_API_KEY', value: 'test-key') }
-    allow(OpenAI::Client).to receive(:new).and_return(client)
+    create(:installation_config, name: 'CAPTAIN_OPEN_AI_API_KEY', value: 'test-key')
     allow(Captain::Llm::EmbeddingService).to receive(:new).and_return(embedding_service)
+    allow(RubyLLM).to receive(:chat).and_return(mock_chat)
+    allow(mock_chat).to receive(:with_temperature).and_return(mock_chat)
+    allow(mock_chat).to receive(:with_params).and_return(mock_chat)
+    allow(mock_chat).to receive(:with_instructions).and_return(mock_chat)
+    allow(mock_chat).to receive(:ask).and_return(mock_response)
   end
 
   describe '#generate_and_deduplicate' do
-    let(:sample_faqs) do
-      [
-        { 'question' => 'What is the purpose?', 'answer' => 'To help users.' },
-        { 'question' => 'How does it work?', 'answer' => 'Through AI.' }
-      ]
-    end
-
-    let(:openai_response) do
-      {
-        'choices' => [
-          {
-            'message' => {
-              'content' => { faqs: sample_faqs }.to_json
-            }
-          }
-        ]
-      }
-    end
-
     context 'when successful' do
       before do
-        allow(client).to receive(:chat).and_return(openai_response)
         allow(embedding_service).to receive(:get_embedding).and_return([0.1, 0.2, 0.3])
         allow(captain_assistant.responses).to receive(:nearest_neighbors).and_return([])
       end
 
-      it 'creates new FAQs' do
+      it 'creates new FAQs for valid conversation content' do
         expect do
           service.generate_and_deduplicate
         end.to change(captain_assistant.responses, :count).by(2)
       end
 
-      it 'saves the correct FAQ content' do
+      it 'saves FAQs with pending status linked to conversation' do
         service.generate_and_deduplicate
         expect(
           captain_assistant.responses.pluck(:question, :answer, :status, :documentable_id)
@@ -63,6 +56,11 @@ RSpec.describe Captain::Llm::ConversationFaqService do
       it 'returns an empty array without generating FAQs' do
         expect(service.generate_and_deduplicate).to eq([])
       end
+
+      it 'does not call the LLM API' do
+        expect(RubyLLM).not_to receive(:chat)
+        service.generate_and_deduplicate
+      end
     end
 
     context 'when finding duplicates' do
@@ -70,9 +68,6 @@ RSpec.describe Captain::Llm::ConversationFaqService do
         create(:captain_assistant_response, assistant: captain_assistant, question: 'Similar question', answer: 'Similar answer')
       end
       let(:similar_neighbor) do
-        # Using OpenStruct here to mock as the Captain:AssistantResponse does not implement
-        # neighbor_distance as a method or attribute rather it is returned directly
-        # from SQL query in neighbor gem
         OpenStruct.new(
           id: 1,
           question: existing_response.question,
@@ -82,87 +77,78 @@ RSpec.describe Captain::Llm::ConversationFaqService do
       end
 
       before do
-        allow(client).to receive(:chat).and_return(openai_response)
         allow(embedding_service).to receive(:get_embedding).and_return([0.1, 0.2, 0.3])
         allow(captain_assistant.responses).to receive(:nearest_neighbors).and_return([similar_neighbor])
       end
 
-      it 'filters out duplicate FAQs' do
+      it 'filters out duplicate FAQs based on embedding similarity' do
         expect do
           service.generate_and_deduplicate
         end.not_to change(captain_assistant.responses, :count)
       end
     end
 
-    context 'when OpenAI API fails' do
+    context 'when LLM API fails' do
       before do
-        allow(client).to receive(:chat).and_raise(OpenAI::Error.new('API Error'))
+        allow(mock_chat).to receive(:ask).and_raise(RubyLLM::Error.new(nil, 'API Error'))
+        allow(Rails.logger).to receive(:error)
       end
 
-      it 'handles the error and returns empty array' do
-        expect(Rails.logger).to receive(:error).with('OpenAI API Error: API Error')
+      it 'returns empty array and logs the error' do
+        expect(Rails.logger).to receive(:error).with('LLM API Error: API Error')
         expect(service.generate_and_deduplicate).to eq([])
       end
     end
 
     context 'when JSON parsing fails' do
       let(:invalid_response) do
-        {
-          'choices' => [
-            {
-              'message' => {
-                'content' => 'invalid json'
-              }
-            }
-          ]
-        }
+        instance_double(RubyLLM::Message, content: 'invalid json')
       end
 
       before do
-        allow(client).to receive(:chat).and_return(invalid_response)
+        allow(mock_chat).to receive(:ask).and_return(invalid_response)
       end
 
-      it 'handles JSON parsing errors' do
+      it 'handles JSON parsing errors gracefully' do
         expect(Rails.logger).to receive(:error).with(/Error in parsing GPT processed response:/)
         expect(service.generate_and_deduplicate).to eq([])
       end
     end
+
+    context 'when response content is nil' do
+      let(:nil_response) do
+        instance_double(RubyLLM::Message, content: nil)
+      end
+
+      before do
+        allow(mock_chat).to receive(:ask).and_return(nil_response)
+      end
+
+      it 'returns empty array' do
+        expect(service.generate_and_deduplicate).to eq([])
+      end
+    end
   end
 
-  describe '#chat_parameters' do
-    it 'includes correct model and response format' do
-      params = service.send(:chat_parameters)
-      expect(params[:model]).to eq('gpt-4o-mini')
-      expect(params[:response_format]).to eq({ type: 'json_object' })
-    end
-
-    it 'includes system prompt and conversation content' do
-      allow(Captain::Llm::SystemPromptsService).to receive(:conversation_faq_generator).and_return('system prompt')
-      params = service.send(:chat_parameters)
-
-      expect(params[:messages]).to include(
-        { role: 'system', content: 'system prompt' },
-        { role: 'user', content: conversation.to_llm_text }
-      )
-    end
-
+  describe 'language handling' do
     context 'when conversation has different language' do
       let(:account) { create(:account, locale: 'fr') }
       let(:conversation) do
-        create(:conversation, account: account,
-                              first_reply_created_at: Time.zone.now)
+        create(:conversation, account: account, first_reply_created_at: Time.zone.now)
       end
 
-      it 'includes system prompt with correct language' do
-        allow(Captain::Llm::SystemPromptsService).to receive(:conversation_faq_generator)
+      before do
+        allow(embedding_service).to receive(:get_embedding).and_return([0.1, 0.2, 0.3])
+        allow(captain_assistant.responses).to receive(:nearest_neighbors).and_return([])
+      end
+
+      it 'uses account language for system prompt' do
+        expect(Captain::Llm::SystemPromptsService).to receive(:conversation_faq_generator)
           .with('french')
-          .and_return('system prompt in french')
+          .at_least(:once)
+          .and_call_original
 
-        params = service.send(:chat_parameters)
-
-        expect(params[:messages]).to include(
-          { role: 'system', content: 'system prompt in french' }
-        )
+        service.generate_and_deduplicate
       end
     end
   end
diff --git a/spec/enterprise/services/captain/llm/faq_generator_service_spec.rb b/spec/enterprise/services/captain/llm/faq_generator_service_spec.rb
index 7d799dc18..003d5b715 100644
--- a/spec/enterprise/services/captain/llm/faq_generator_service_spec.rb
+++ b/spec/enterprise/services/captain/llm/faq_generator_service_spec.rb
@@ -4,58 +4,40 @@ RSpec.describe Captain::Llm::FaqGeneratorService do
   let(:content) { 'Sample content for FAQ generation' }
   let(:language) { 'english' }
   let(:service) { described_class.new(content, language) }
-  let(:client) { instance_double(OpenAI::Client) }
+  let(:mock_chat) { instance_double(RubyLLM::Chat) }
+  let(:sample_faqs) do
+    [
+      { 'question' => 'What is this service?', 'answer' => 'It generates FAQs.' },
+      { 'question' => 'How does it work?', 'answer' => 'Using AI technology.' }
+    ]
+  end
+  let(:mock_response) do
+    instance_double(RubyLLM::Message, content: { faqs: sample_faqs }.to_json)
+  end
 
   before do
     create(:installation_config, name: 'CAPTAIN_OPEN_AI_API_KEY', value: 'test-key')
-    allow(OpenAI::Client).to receive(:new).and_return(client)
+    allow(RubyLLM).to receive(:chat).and_return(mock_chat)
+    allow(mock_chat).to receive(:with_temperature).and_return(mock_chat)
+    allow(mock_chat).to receive(:with_params).and_return(mock_chat)
+    allow(mock_chat).to receive(:with_instructions).and_return(mock_chat)
+    allow(mock_chat).to receive(:ask).and_return(mock_response)
   end
 
   describe '#generate' do
-    let(:sample_faqs) do
-      [
-        { 'question' => 'What is this service?', 'answer' => 'It generates FAQs.' },
-        { 'question' => 'How does it work?', 'answer' => 'Using AI technology.' }
-      ]
-    end
-
-    let(:openai_response) do
-      {
-        'choices' => [
-          {
-            'message' => {
-              'content' => { faqs: sample_faqs }.to_json
-            }
-          }
-        ]
-      }
-    end
-
     context 'when successful' do
-      before do
-        allow(client).to receive(:chat).and_return(openai_response)
-        allow(Captain::Llm::SystemPromptsService).to receive(:faq_generator).and_return('system prompt')
-      end
-
-      it 'returns parsed FAQs' do
+      it 'returns parsed FAQs from the LLM response' do
         result = service.generate
         expect(result).to eq(sample_faqs)
       end
 
-      it 'calls OpenAI client with chat parameters' do
-        expect(client).to receive(:chat).with(parameters: hash_including(
-          model: 'gpt-4o-mini',
-          response_format: { type: 'json_object' },
-          messages: array_including(
-            hash_including(role: 'system'),
-            hash_including(role: 'user', content: content)
-          )
-        ))
+      it 'sends content to LLM with JSON response format' do
+        expect(mock_chat).to receive(:with_params).with(response_format: { type: 'json_object' }).and_return(mock_chat)
         service.generate
       end
 
-      it 'calls SystemPromptsService with correct language' do
-        expect(Captain::Llm::SystemPromptsService).to receive(:faq_generator).with(language)
+      it 'uses SystemPromptsService with the specified language' do
+        expect(Captain::Llm::SystemPromptsService).to receive(:faq_generator).with(language).at_least(:once).and_call_original
         service.generate
       end
     end
@@ -63,23 +45,57 @@ RSpec.describe Captain::Llm::FaqGeneratorService do
     context 'with different language' do
       let(:language) { 'spanish' }
 
-      before do
-        allow(client).to receive(:chat).and_return(openai_response)
-      end
-
       it 'passes the correct language to SystemPromptsService' do
-        expect(Captain::Llm::SystemPromptsService).to receive(:faq_generator).with('spanish')
+        expect(Captain::Llm::SystemPromptsService).to receive(:faq_generator).with('spanish').at_least(:once).and_call_original
         service.generate
       end
     end
 
-    context 'when OpenAI API fails' do
+    context 'when LLM API fails' do
       before do
-        allow(client).to receive(:chat).and_raise(OpenAI::Error.new('API Error'))
+        allow(mock_chat).to receive(:ask).and_raise(RubyLLM::Error.new(nil, 'API Error'))
+        allow(Rails.logger).to receive(:error)
       end
 
-      it 'handles the error and returns empty array' do
-        expect(Rails.logger).to receive(:error).with('OpenAI API Error: API Error')
+      it 'returns empty array and logs the error' do
+        expect(Rails.logger).to receive(:error).with('LLM API Error: API Error')
+        expect(service.generate).to eq([])
+      end
+    end
+
+    context 'when response content is nil' do
+      let(:nil_response) { instance_double(RubyLLM::Message, content: nil) }
+
+      before do
+        allow(mock_chat).to receive(:ask).and_return(nil_response)
+      end
+
+      it 'returns empty array' do
+        expect(service.generate).to eq([])
+      end
+    end
+
+    context 'when JSON parsing fails' do
+      let(:invalid_response) { instance_double(RubyLLM::Message, content: 'invalid json') }
+
+      before do
+        allow(mock_chat).to receive(:ask).and_return(invalid_response)
+      end
+
+      it 'logs error and returns empty array' do
+        expect(Rails.logger).to receive(:error).with(/Error in parsing GPT processed response:/)
+        expect(service.generate).to eq([])
+      end
+    end
+
+    context 'when response is missing faqs key' do
+      let(:missing_key_response) { instance_double(RubyLLM::Message, content: '{"data": []}') }
+
+      before do
+        allow(mock_chat).to receive(:ask).and_return(missing_key_response)
+      end
+
+      it 'returns empty array via KeyError rescue' do
         expect(service.generate).to eq([])
       end
     end
diff --git a/spec/enterprise/services/captain/onboarding/website_analyzer_service_spec.rb b/spec/enterprise/services/captain/onboarding/website_analyzer_service_spec.rb
index a2735bd69..4dec4c051 100644
--- a/spec/enterprise/services/captain/onboarding/website_analyzer_service_spec.rb
+++ b/spec/enterprise/services/captain/onboarding/website_analyzer_service_spec.rb
@@ -4,40 +4,38 @@ RSpec.describe Captain::Onboarding::WebsiteAnalyzerService do
   let(:website_url) { 'https://example.com' }
   let(:service) { described_class.new(website_url) }
   let(:mock_crawler) { instance_double(Captain::Tools::SimplePageCrawlService) }
-  let(:mock_client) { instance_double(OpenAI::Client) }
+  let(:mock_chat) { instance_double(RubyLLM::Chat) }
+  let(:business_info) do
+    {
+      'business_name' => 'Example Corp',
+      'suggested_assistant_name' => 'Alex from Example Corp',
+      'description' => 'You specialize in helping customers with business solutions and support'
+    }
+  end
+  let(:mock_response) do
+    instance_double(RubyLLM::Message, content: business_info.to_json)
+  end
 
   before do
     create(:installation_config, name: 'CAPTAIN_OPEN_AI_API_KEY', value: 'test-key')
     allow(Captain::Tools::SimplePageCrawlService).to receive(:new).and_return(mock_crawler)
-    allow(service).to receive(:client).and_return(mock_client)
-    allow(service).to receive(:model).and_return('gpt-3.5-turbo')
+    allow(RubyLLM).to receive(:chat).and_return(mock_chat)
+    allow(mock_chat).to receive(:with_temperature).and_return(mock_chat)
+    allow(mock_chat).to receive(:with_params).and_return(mock_chat)
+    allow(mock_chat).to receive(:with_instructions).and_return(mock_chat)
+    allow(mock_chat).to receive(:ask).and_return(mock_response)
   end
 
   describe '#analyze' do
-    context 'when website content is available and OpenAI call is successful' do
-      let(:openai_response) do
-        {
-          'choices' => [{
-            'message' => {
-              'content' => {
-                'business_name' => 'Example Corp',
-                'suggested_assistant_name' => 'Alex from Example Corp',
-                'description' => 'You specialize in helping customers with business solutions and support'
-              }.to_json
-            }
-          }]
-        }
-      end
-
+    context 'when website content is available and LLM call is successful' do
       before do
         allow(mock_crawler).to receive(:body_text_content).and_return('Welcome to Example Corp')
         allow(mock_crawler).to receive(:page_title).and_return('Example Corp - Home')
         allow(mock_crawler).to receive(:meta_description).and_return('Leading provider of business solutions')
         allow(mock_crawler).to receive(:favicon_url).and_return('https://example.com/favicon.ico')
-        allow(mock_client).to receive(:chat).and_return(openai_response)
       end
 
-      it 'returns success' do
+      it 'returns successful analysis with extracted business info' do
         result = service.analyze
 
         expect(result[:success]).to be true
@@ -49,14 +47,19 @@ RSpec.describe Captain::Onboarding::WebsiteAnalyzerService do
           favicon_url: 'https://example.com/favicon.ico'
         )
       end
+
+      it 'uses low temperature for deterministic analysis' do
+        expect(mock_chat).to receive(:with_temperature).with(0.1).and_return(mock_chat)
+        service.analyze
+      end
     end
 
-    context 'when website content is errored' do
+    context 'when website content fetch raises an error' do
       before do
         allow(mock_crawler).to receive(:body_text_content).and_raise(StandardError, 'Network error')
       end
 
-      it 'returns error' do
+      it 'returns error response' do
         result = service.analyze
 
         expect(result[:success]).to be false
@@ -64,14 +67,14 @@ RSpec.describe Captain::Onboarding::WebsiteAnalyzerService do
       end
     end
 
-    context 'when website content is unavailable' do
+    context 'when website content is empty' do
       before do
         allow(mock_crawler).to receive(:body_text_content).and_return('')
         allow(mock_crawler).to receive(:page_title).and_return('')
         allow(mock_crawler).to receive(:meta_description).and_return('')
       end
 
-      it 'returns error' do
+      it 'returns error for unavailable content' do
         result = service.analyze
 
         expect(result[:success]).to be false
@@ -79,21 +82,57 @@ RSpec.describe Captain::Onboarding::WebsiteAnalyzerService do
       end
     end
 
-    context 'when OpenAI error' do
+    context 'when LLM call fails' do
       before do
         allow(mock_crawler).to receive(:body_text_content).and_return('Welcome to Example Corp')
         allow(mock_crawler).to receive(:page_title).and_return('Example Corp - Home')
         allow(mock_crawler).to receive(:meta_description).and_return('Leading provider of business solutions')
         allow(mock_crawler).to receive(:favicon_url).and_return('https://example.com/favicon.ico')
-        allow(mock_client).to receive(:chat).and_raise(StandardError, 'API error')
+        allow(mock_chat).to receive(:ask).and_raise(StandardError, 'API error')
       end
 
-      it 'returns error' do
+      it 'returns error response with message' do
         result = service.analyze
 
         expect(result[:success]).to be false
         expect(result[:error]).to eq('API error')
       end
     end
+
+    context 'when LLM returns invalid JSON' do
+      let(:invalid_response) { instance_double(RubyLLM::Message, content: 'not valid json') }
+
+      before do
+        allow(mock_crawler).to receive(:body_text_content).and_return('Welcome to Example Corp')
+        allow(mock_crawler).to receive(:page_title).and_return('Example Corp - Home')
+        allow(mock_crawler).to receive(:meta_description).and_return('Leading provider of business solutions')
+        allow(mock_crawler).to receive(:favicon_url).and_return('https://example.com/favicon.ico')
+        allow(mock_chat).to receive(:ask).and_return(invalid_response)
+      end
+
+      it 'returns error for parsing failure' do
+        result = service.analyze
+
+        expect(result[:success]).to be false
+        expect(result[:error]).to eq('Failed to parse business information from website')
+      end
+    end
+
+    context 'when URL normalization is needed' do
+      let(:website_url) { 'example.com' }
+
+      before do
+        allow(mock_crawler).to receive(:body_text_content).and_return('Welcome')
+        allow(mock_crawler).to receive(:page_title).and_return('Example')
+        allow(mock_crawler).to receive(:meta_description).and_return('Description')
+        allow(mock_crawler).to receive(:favicon_url).and_return(nil)
+      end
+
+      it 'normalizes URL by adding https prefix' do
+        result = service.analyze
+
+        expect(result[:data][:website_url]).to eq('https://example.com')
+      end
+    end
   end
 end
diff --git a/spec/enterprise/services/enterprise/billing/handle_stripe_event_service_spec.rb b/spec/enterprise/services/enterprise/billing/handle_stripe_event_service_spec.rb
index db029ad0f..0f8ce1494 100644
--- a/spec/enterprise/services/enterprise/billing/handle_stripe_event_service_spec.rb
+++ b/spec/enterprise/services/enterprise/billing/handle_stripe_event_service_spec.rb
@@ -32,6 +32,7 @@ describe Enterprise::Billing::HandleStripeEventService do
     # Setup common subscription mocks
     allow(event).to receive(:data).and_return(data)
     allow(data).to receive(:object).and_return(subscription)
+    allow(data).to receive(:previous_attributes).and_return({})
     allow(subscription).to receive(:[]).with('quantity').and_return('10')
     allow(subscription).to receive(:[]).with('status').and_return('active')
     allow(subscription).to receive(:[]).with('current_period_end').and_return(1_686_567_520)
@@ -62,7 +63,7 @@ describe Enterprise::Billing::HandleStripeEventService do
       expect(account).not_to be_feature_enabled('audit_logs')
     end
 
-    it 'resets captain usage on subscription update' do
+    it 'resets captain usage on billing period renewal' do
       # Prime the account with some usage
       5.times { account.increment_response_usage }
       expect(account.custom_attributes['captain_responses_usage']).to eq(5)
@@ -70,6 +71,10 @@ describe Enterprise::Billing::HandleStripeEventService do
       # Setup for any plan
       allow(subscription).to receive(:[]).with('plan')
                                          .and_return({ 'id' => 'test', 'product' => 'plan_id_startups', 'name' => 'Startups' })
+      allow(subscription).to receive(:[]).with('current_period_start').and_return(1_686_567_520)
+
+      # Simulate billing period renewal with previous_attributes showing old period
+      allow(data).to receive(:previous_attributes).and_return({ 'current_period_start' => 1_683_975_520 })
 
       stripe_event_service.new.perform(event: event)
 
diff --git a/spec/enterprise/services/enterprise/message_templates/hook_execution_service_spec.rb b/spec/enterprise/services/enterprise/message_templates/hook_execution_service_spec.rb
new file mode 100644
index 000000000..9074baa57
--- /dev/null
+++ b/spec/enterprise/services/enterprise/message_templates/hook_execution_service_spec.rb
@@ -0,0 +1,295 @@
+require 'rails_helper'
+
+RSpec.describe MessageTemplates::HookExecutionService do
+  let(:account) { create(:account, custom_attributes: { plan_name: 'startups' }) }
+  let(:inbox) { create(:inbox, account: account) }
+  let(:contact) { create(:contact, account: account) }
+  let(:conversation) { create(:conversation, inbox: inbox, account: account, contact: contact, status: :pending) }
+  let(:assistant) { create(:captain_assistant, account: account) }
+
+  before do
+    create(:captain_inbox, captain_assistant: assistant, inbox: inbox)
+  end
+
+  context 'when captain assistant is configured' do
+    context 'when within business hours' do
+      before do
+        inbox.update!(working_hours_enabled: true)
+        inbox.working_hours.find_by(day_of_week: Time.current.in_time_zone(inbox.timezone).wday).update!(
+          open_all_day: true,
+          closed_all_day: false
+        )
+      end
+
+      it 'schedules captain response job for incoming messages on pending conversations' do
+        expect(Captain::Conversation::ResponseBuilderJob).to receive(:perform_later).with(conversation, assistant)
+
+        create(:message, conversation: conversation, message_type: :incoming)
+      end
+    end
+
+    context 'when outside business hours' do
+      before do
+        inbox.update!(
+          working_hours_enabled: true,
+          out_of_office_message: 'We are currently closed'
+        )
+        inbox.working_hours.find_by(day_of_week: Time.current.in_time_zone(inbox.timezone).wday).update!(
+          closed_all_day: true,
+          open_all_day: false
+        )
+      end
+
+      it 'schedules captain response job outside business hours (Captain always responds when configured)' do
+        expect(Captain::Conversation::ResponseBuilderJob).to receive(:perform_later).with(conversation, assistant)
+
+        create(:message, conversation: conversation, message_type: :incoming)
+      end
+
+      it 'performs captain handoff when quota is exceeded (OOO template will kick in after handoff)' do
+        account.update!(
+          limits: { 'captain_responses' => 100 },
+          custom_attributes: account.custom_attributes.merge('captain_responses_usage' => 100)
+        )
+
+        create(:message, conversation: conversation, message_type: :incoming)
+
+        expect(conversation.reload.status).to eq('open')
+      end
+
+      it 'does not send out of office message when Captain is handling' do
+        out_of_office_service = instance_double(MessageTemplates::Template::OutOfOffice)
+        allow(MessageTemplates::Template::OutOfOffice).to receive(:new).and_return(out_of_office_service)
+        allow(out_of_office_service).to receive(:perform).and_return(true)
+
+        create(:message, conversation: conversation, message_type: :incoming)
+
+        expect(MessageTemplates::Template::OutOfOffice).not_to have_received(:new)
+      end
+    end
+
+    context 'when business hours are not enabled' do
+      before do
+        inbox.update!(working_hours_enabled: false)
+      end
+
+      it 'schedules captain response job regardless of time' do
+        expect(Captain::Conversation::ResponseBuilderJob).to receive(:perform_later).with(conversation, assistant)
+
+        create(:message, conversation: conversation, message_type: :incoming)
+      end
+    end
+
+    context 'when captain quota is exceeded within business hours' do
+      before do
+        inbox.update!(working_hours_enabled: true)
+        inbox.working_hours.find_by(day_of_week: Time.current.in_time_zone(inbox.timezone).wday).update!(
+          open_all_day: true,
+          closed_all_day: false
+        )
+
+        account.update!(
+          limits: { 'captain_responses' => 100 },
+          custom_attributes: account.custom_attributes.merge('captain_responses_usage' => 100)
+        )
+      end
+
+      it 'performs handoff within business hours when quota exceeded' do
+        create(:message, conversation: conversation, message_type: :incoming)
+
+        expect(conversation.reload.status).to eq('open')
+      end
+    end
+  end
+
+  context 'when no captain assistant is configured' do
+    before do
+      CaptainInbox.where(inbox: inbox).destroy_all
+    end
+
+    it 'does not schedule captain response job' do
+      expect(Captain::Conversation::ResponseBuilderJob).not_to receive(:perform_later)
+
+      create(:message, conversation: conversation, message_type: :incoming)
+    end
+  end
+
+  context 'when conversation is not pending' do
+    before do
+      conversation.update!(status: :open)
+    end
+
+    it 'does not schedule captain response job' do
+      expect(Captain::Conversation::ResponseBuilderJob).not_to receive(:perform_later)
+
+      create(:message, conversation: conversation, message_type: :incoming)
+    end
+  end
+
+  context 'when message is outgoing' do
+    it 'does not schedule captain response job' do
+      expect(Captain::Conversation::ResponseBuilderJob).not_to receive(:perform_later)
+
+      create(:message, conversation: conversation, message_type: :outgoing)
+    end
+  end
+
+  context 'when greeting and out of office messages with Captain enabled' do
+    context 'when conversation is pending (Captain is handling)' do
+      before do
+        conversation.update!(status: :pending)
+      end
+
+      it 'does not create greeting message in conversation' do
+        inbox.update!(greeting_enabled: true, greeting_message: 'Hello! How can we help you?', enable_email_collect: false)
+
+        expect do
+          create(:message, conversation: conversation, message_type: :incoming)
+        end.not_to(change { conversation.reload.messages.template.count })
+      end
+
+      it 'does not create out of office message in conversation' do
+        inbox.update!(
+          working_hours_enabled: true,
+          out_of_office_message: 'We are currently closed',
+          enable_email_collect: false
+        )
+        inbox.working_hours.find_by(day_of_week: Time.current.in_time_zone(inbox.timezone).wday).update!(
+          closed_all_day: true,
+          open_all_day: false
+        )
+
+        expect do
+          create(:message, conversation: conversation, message_type: :incoming)
+        end.not_to(change { conversation.reload.messages.template.count })
+      end
+    end
+
+    context 'when conversation is open (transferred to agent)' do
+      before do
+        conversation.update!(status: :open)
+      end
+
+      it 'creates greeting message in conversation' do
+        inbox.update!(greeting_enabled: true, greeting_message: 'Hello! How can we help you?', enable_email_collect: false)
+
+        expect do
+          create(:message, conversation: conversation, message_type: :incoming)
+        end.to change { conversation.reload.messages.template.count }.by(1)
+
+        greeting_message = conversation.reload.messages.template.last
+        expect(greeting_message.content).to eq('Hello! How can we help you?')
+      end
+
+      it 'creates out of office message when outside business hours' do
+        inbox.update!(
+          working_hours_enabled: true,
+          out_of_office_message: 'We are currently closed',
+          enable_email_collect: false
+        )
+        inbox.working_hours.find_by(day_of_week: Time.current.in_time_zone(inbox.timezone).wday).update!(
+          closed_all_day: true,
+          open_all_day: false
+        )
+
+        expect do
+          create(:message, conversation: conversation, message_type: :incoming)
+        end.to change { conversation.reload.messages.template.count }.by(1)
+
+        out_of_office_message = conversation.reload.messages.template.last
+        expect(out_of_office_message.content).to eq('We are currently closed')
+      end
+    end
+  end
+
+  context 'when Captain is not configured' do
+    before do
+      CaptainInbox.where(inbox: inbox).destroy_all
+    end
+
+    it 'creates greeting message in conversation' do
+      inbox.update!(greeting_enabled: true, greeting_message: 'Hello! How can we help you?', enable_email_collect: false)
+
+      expect do
+        create(:message, conversation: conversation, message_type: :incoming)
+      end.to change { conversation.reload.messages.template.count }.by(1)
+
+      greeting_message = conversation.reload.messages.template.last
+      expect(greeting_message.content).to eq('Hello! How can we help you?')
+    end
+
+    it 'creates out of office message when outside business hours' do
+      inbox.update!(
+        working_hours_enabled: true,
+        out_of_office_message: 'We are currently closed',
+        enable_email_collect: false
+      )
+      inbox.working_hours.find_by(day_of_week: Time.current.in_time_zone(inbox.timezone).wday).update!(
+        closed_all_day: true,
+        open_all_day: false
+      )
+
+      expect do
+        create(:message, conversation: conversation, message_type: :incoming)
+      end.to change { conversation.reload.messages.template.count }.by(1)
+
+      out_of_office_message = conversation.reload.messages.template.last
+      expect(out_of_office_message.content).to eq('We are currently closed')
+    end
+  end
+
+  context 'when Captain quota is exceeded and handoff happens' do
+    before do
+      account.update!(
+        limits: { 'captain_responses' => 100 },
+        custom_attributes: account.custom_attributes.merge('captain_responses_usage' => 100)
+      )
+    end
+
+    context 'when outside business hours' do
+      before do
+        inbox.update!(
+          working_hours_enabled: true,
+          out_of_office_message: 'We are currently closed. Please leave your email.',
+          enable_email_collect: false
+        )
+        inbox.working_hours.find_by(day_of_week: Time.current.in_time_zone(inbox.timezone).wday).update!(
+          closed_all_day: true,
+          open_all_day: false
+        )
+      end
+
+      it 'sends out of office message after handoff due to quota exceeded' do
+        expect do
+          create(:message, conversation: conversation, message_type: :incoming)
+        end.to change { conversation.messages.template.count }.by(1)
+
+        expect(conversation.reload.status).to eq('open')
+        ooo_message = conversation.messages.template.last
+        expect(ooo_message.content).to eq('We are currently closed. Please leave your email.')
+      end
+    end
+
+    context 'when within business hours' do
+      before do
+        inbox.update!(
+          working_hours_enabled: true,
+          out_of_office_message: 'We are currently closed.',
+          enable_email_collect: false
+        )
+        inbox.working_hours.find_by(day_of_week: Time.current.in_time_zone(inbox.timezone).wday).update!(
+          open_all_day: true,
+          closed_all_day: false
+        )
+      end
+
+      it 'does not send out of office message after handoff' do
+        expect do
+          create(:message, conversation: conversation, message_type: :incoming)
+        end.not_to(change { conversation.messages.template.count })
+
+        expect(conversation.reload.status).to eq('open')
+      end
+    end
+  end
+end
diff --git a/spec/enterprise/services/internal/account_analysis/content_evaluator_service_spec.rb b/spec/enterprise/services/internal/account_analysis/content_evaluator_service_spec.rb
index d7bf26c35..f959a9afa 100644
--- a/spec/enterprise/services/internal/account_analysis/content_evaluator_service_spec.rb
+++ b/spec/enterprise/services/internal/account_analysis/content_evaluator_service_spec.rb
@@ -3,60 +3,103 @@ require 'rails_helper'
 RSpec.describe Internal::AccountAnalysis::ContentEvaluatorService do
   let(:service) { described_class.new }
   let(:content) { 'This is some test content' }
+  let(:mock_moderation_result) do
+    instance_double(
+      RubyLLM::Moderation,
+      flagged?: false,
+      flagged_categories: [],
+      category_scores: {}
+    )
+  end
 
   before do
     create(:installation_config, name: 'CAPTAIN_OPEN_AI_API_KEY', value: 'test-key')
+    allow(RubyLLM).to receive(:moderate).and_return(mock_moderation_result)
   end
 
   describe '#evaluate' do
-    context 'when content is present' do
-      let(:llm_response) do
-        {
-          'choices' => [
-            {
-              'message' => {
-                'content' => {
-                  'threat_level' => 'low',
-                  'threat_summary' => 'No significant threats detected',
-                  'detected_threats' => ['minor_concern'],
-                  'illegal_activities_detected' => false,
-                  'recommendation' => 'approve'
-                }.to_json
-              }
-            }
-          ]
-        }
-      end
-
-      before do
-        allow(service).to receive(:send_to_llm).and_return(llm_response)
-        allow(Rails.logger).to receive(:info)
-      end
-
-      it 'returns the evaluation results' do
+    context 'when content is safe' do
+      it 'returns safe evaluation with approval recommendation' do
         result = service.evaluate(content)
 
         expect(result).to include(
-          'threat_level' => 'low',
-          'threat_summary' => 'No significant threats detected',
-          'detected_threats' => ['minor_concern'],
+          'threat_level' => 'safe',
+          'threat_summary' => 'No threats detected',
+          'detected_threats' => [],
           'illegal_activities_detected' => false,
           'recommendation' => 'approve'
         )
       end
 
       it 'logs the evaluation results' do
+        expect(Rails.logger).to receive(:info).with('Moderation evaluation - Level: safe, Threats: ')
         service.evaluate(content)
+      end
+    end
 
-        expect(Rails.logger).to have_received(:info).with('LLM evaluation - Level: low, Illegal activities: false')
+    context 'when content is flagged' do
+      let(:mock_moderation_result) do
+        instance_double(
+          RubyLLM::Moderation,
+          flagged?: true,
+          flagged_categories: %w[harassment hate],
+          category_scores: { 'harassment' => 0.6, 'hate' => 0.3 }
+        )
+      end
+
+      it 'returns flagged evaluation with review recommendation' do
+        result = service.evaluate(content)
+
+        expect(result).to include(
+          'threat_level' => 'high',
+          'threat_summary' => 'Content flagged for: harassment, hate',
+          'detected_threats' => %w[harassment hate],
+          'illegal_activities_detected' => false,
+          'recommendation' => 'review'
+        )
+      end
+    end
+
+    context 'when content contains violence' do
+      let(:mock_moderation_result) do
+        instance_double(
+          RubyLLM::Moderation,
+          flagged?: true,
+          flagged_categories: ['violence'],
+          category_scores: { 'violence' => 0.9 }
+        )
+      end
+
+      it 'marks illegal activities detected for violence' do
+        result = service.evaluate(content)
+
+        expect(result['illegal_activities_detected']).to be true
+        expect(result['threat_level']).to eq('critical')
+      end
+    end
+
+    context 'when content contains self-harm' do
+      let(:mock_moderation_result) do
+        instance_double(
+          RubyLLM::Moderation,
+          flagged?: true,
+          flagged_categories: ['self-harm'],
+          category_scores: { 'self-harm' => 0.85 }
+        )
+      end
+
+      it 'marks illegal activities detected for self-harm' do
+        result = service.evaluate(content)
+
+        expect(result['illegal_activities_detected']).to be true
       end
     end
 
     context 'when content is blank' do
       let(:blank_content) { '' }
 
-      it 'returns the default evaluation without calling the LLM' do
-        expect(service).not_to receive(:send_to_llm)
+      it 'returns default evaluation without calling moderation API' do
+        expect(RubyLLM).not_to receive(:moderate)
 
         result = service.evaluate(blank_content)
 
@@ -70,34 +113,16 @@ RSpec.describe Internal::AccountAnalysis::ContentEvaluatorService do
       end
     end
 
-    context 'when LLM response is nil' do
-      before do
-        allow(service).to receive(:send_to_llm).and_return(nil)
-      end
-
-      it 'returns the default evaluation' do
-        result = service.evaluate(content)
-
-        expect(result).to include(
-          'threat_level' => 'unknown',
-          'threat_summary' => 'Failed to complete content evaluation',
-          'detected_threats' => [],
-          'illegal_activities_detected' => false,
-          'recommendation' => 'review'
-        )
-      end
-    end
-
     context 'when error occurs during evaluation' do
       before do
-        allow(service).to receive(:send_to_llm).and_raise(StandardError.new('Test error'))
-        allow(Rails.logger).to receive(:error)
+        allow(RubyLLM).to receive(:moderate).and_raise(StandardError.new('Test error'))
       end
 
-      it 'logs the error and returns default evaluation with error type' do
+      it 'logs error and returns default evaluation with error type' do
+        expect(Rails.logger).to receive(:error).with('Error evaluating content: Test error')
+
         result = service.evaluate(content)
 
-        expect(Rails.logger).to have_received(:error).with('Error evaluating content: Test error')
         expect(result).to include(
           'threat_level' => 'unknown',
           'threat_summary' => 'Failed to complete content evaluation',
@@ -107,5 +132,68 @@ RSpec.describe Internal::AccountAnalysis::ContentEvaluatorService do
         )
       end
     end
+
+    context 'with threat level determination' do
+      it 'returns critical for scores >= 0.8' do
+        mock_result = instance_double(
+          RubyLLM::Moderation,
+          flagged?: true,
+          flagged_categories: ['harassment'],
+          category_scores: { 'harassment' => 0.85 }
+        )
+        allow(RubyLLM).to receive(:moderate).and_return(mock_result)
+
+        result = service.evaluate(content)
+        expect(result['threat_level']).to eq('critical')
+      end
+
+      it 'returns high for scores between 0.5 and 0.8' do
+        mock_result = instance_double(
+          RubyLLM::Moderation,
+          flagged?: true,
+          flagged_categories: ['harassment'],
+          category_scores: { 'harassment' => 0.65 }
+        )
+        allow(RubyLLM).to receive(:moderate).and_return(mock_result)
+
+        result = service.evaluate(content)
+        expect(result['threat_level']).to eq('high')
+      end
+
+      it 'returns medium for scores between 0.2 and 0.5' do
+        mock_result = instance_double(
+          RubyLLM::Moderation,
+          flagged?: true,
+          flagged_categories: ['harassment'],
+          category_scores: { 'harassment' => 0.35 }
+        )
+        allow(RubyLLM).to receive(:moderate).and_return(mock_result)
+
+        result = service.evaluate(content)
+        expect(result['threat_level']).to eq('medium')
+      end
+
+      it 'returns low for scores below 0.2' do
+        mock_result = instance_double(
+          RubyLLM::Moderation,
+          flagged?: true,
+          flagged_categories: ['harassment'],
+          category_scores: { 'harassment' => 0.15 }
+        )
+        allow(RubyLLM).to receive(:moderate).and_return(mock_result)
+
+        result = service.evaluate(content)
+        expect(result['threat_level']).to eq('low')
+      end
+    end
+
+    context 'with content truncation' do
+      let(:long_content) { 'a' * 15_000 }
+
+      it 'truncates content to 10000 characters before sending to moderation' do
+        expect(RubyLLM).to receive(:moderate).with('a' * 10_000).and_return(mock_moderation_result)
+        service.evaluate(long_content)
+      end
+    end
   end
 end
diff --git a/spec/lib/chatwoot_markdown_renderer_spec.rb b/spec/lib/chatwoot_markdown_renderer_spec.rb
index f11568f43..5b66ed869 100644
--- a/spec/lib/chatwoot_markdown_renderer_spec.rb
+++ b/spec/lib/chatwoot_markdown_renderer_spec.rb
@@ -10,7 +10,7 @@ RSpec.describe ChatwootMarkdownRenderer do
   let(:html_content) { '<p>This is a <em>test</em> content with <sup>markdown</sup></p>' }
 
   before do
-    allow(CommonMarker).to receive(:render_doc).with(markdown_content, :DEFAULT).and_return(doc)
+    allow(CommonMarker).to receive(:render_doc).with(markdown_content, :DEFAULT, [:strikethrough]).and_return(doc)
     allow(CustomMarkdownRenderer).to receive(:new).and_return(markdown_renderer)
     allow(markdown_renderer).to receive(:render).with(doc).and_return(html_content)
   end
@@ -86,6 +86,7 @@ RSpec.describe ChatwootMarkdownRenderer do
     let(:rendered_content) { renderer.render_markdown_to_plain_text }
 
     before do
+      allow(CommonMarker).to receive(:render_doc).with(markdown_content, :DEFAULT).and_return(doc)
       allow(doc).to receive(:to_plaintext).and_return(plain_text_content)
     end
 
diff --git a/spec/models/user_spec.rb b/spec/models/user_spec.rb
index 213988a0d..d263708af 100644
--- a/spec/models/user_spec.rb
+++ b/spec/models/user_spec.rb
@@ -14,7 +14,7 @@ RSpec.describe User do
   context 'with associations' do
     it { is_expected.to have_many(:accounts).through(:account_users) }
     it { is_expected.to have_many(:account_users) }
-    it { is_expected.to have_many(:assigned_conversations).class_name('Conversation').dependent(:nullify) }
+    it { is_expected.to have_many(:assigned_conversations).dependent(:nullify) }
     it { is_expected.to have_many(:inbox_members).dependent(:destroy_async) }
     it { is_expected.to have_many(:notification_settings).dependent(:destroy_async) }
     it { is_expected.to have_many(:messages) }
diff --git a/spec/presenters/message_content_presenter_spec.rb b/spec/presenters/message_content_presenter_spec.rb
index fe709fd21..902d45f13 100644
--- a/spec/presenters/message_content_presenter_spec.rb
+++ b/spec/presenters/message_content_presenter_spec.rb
@@ -10,8 +10,8 @@ RSpec.describe MessageContentPresenter do
       let(:content_type) { 'text' }
       let(:content) { 'Regular message' }
 
-      it 'returns regular content' do
-        expect(presenter.outgoing_content).to eq('Regular message')
+      it 'returns content transformed for channel (HTML for WebWidget)' do
+        expect(presenter.outgoing_content).to eq("<p>Regular message</p>\n")
       end
     end
 
@@ -23,8 +23,8 @@ RSpec.describe MessageContentPresenter do
         allow(message.inbox).to receive(:web_widget?).and_return(true)
       end
 
-      it 'returns regular content without survey URL' do
-        expect(presenter.outgoing_content).to eq('Rate your experience')
+      it 'returns content without survey URL (HTML for WebWidget)' do
+        expect(presenter.outgoing_content).to eq("<p>Rate your experience</p>\n")
       end
     end
 
@@ -36,18 +36,20 @@ RSpec.describe MessageContentPresenter do
         allow(message.inbox).to receive(:web_widget?).and_return(false)
       end
 
-      it 'returns I18n default message when no CSAT config and dynamically generates survey URL' do
+      it 'returns I18n default message when no CSAT config and dynamically generates survey URL (HTML format)' do
         with_modified_env 'FRONTEND_URL' => 'https://app.chatwoot.com' do
           expected_url = "https://app.chatwoot.com/survey/responses/#{conversation.uuid}"
           expect(presenter.outgoing_content).to include(expected_url)
+          expect(presenter.outgoing_content).to include('<p>')
         end
       end
 
-      it 'returns CSAT config message when config exists and dynamically generates survey URL' do
+      it 'returns CSAT config message when config exists and dynamically generates survey URL (HTML format)' do
         with_modified_env 'FRONTEND_URL' => 'https://app.chatwoot.com' do
           allow(message.inbox).to receive(:csat_config).and_return({ 'message' => 'Custom CSAT message' })
           expected_url = "https://app.chatwoot.com/survey/responses/#{conversation.uuid}"
-          expect(presenter.outgoing_content).to eq("Custom CSAT message #{expected_url}")
+          expected_content = "<p>Custom CSAT message #{expected_url}</p>\n"
+          expect(presenter.outgoing_content).to eq(expected_content)
         end
       end
     end
diff --git a/spec/services/messages/markdown_renderer_service_spec.rb b/spec/services/messages/markdown_renderer_service_spec.rb
new file mode 100644
index 000000000..5b8e02e2f
--- /dev/null
+++ b/spec/services/messages/markdown_renderer_service_spec.rb
@@ -0,0 +1,492 @@
+require 'rails_helper'
+
+RSpec.describe Messages::MarkdownRendererService, type: :service do
+  describe '#render' do
+    context 'when content is blank' do
+      it 'returns the content as-is for nil' do
+        result = described_class.new(nil, 'Channel::Whatsapp').render
+        expect(result).to be_nil
+      end
+
+      it 'returns the content as-is for empty string' do
+        result = described_class.new('', 'Channel::Whatsapp').render
+        expect(result).to eq('')
+      end
+    end
+
+    context 'when channel is Channel::Whatsapp' do
+      let(:channel_type) { 'Channel::Whatsapp' }
+
+      it 'converts bold from double to single asterisk' do
+        content = '**bold text**'
+        result = described_class.new(content, channel_type).render
+        expect(result.strip).to eq('*bold text*')
+      end
+
+      it 'keeps italic with underscore' do
+        content = '_italic text_'
+        result = described_class.new(content, channel_type).render
+        expect(result.strip).to eq('_italic text_')
+      end
+
+      it 'keeps code with backticks' do
+        content = '`code`'
+        result = described_class.new(content, channel_type).render
+        expect(result.strip).to eq('`code`')
+      end
+
+      it 'converts links to URLs only' do
+        content = '[link text](https://example.com)'
+        result = described_class.new(content, channel_type).render
+        expect(result.strip).to eq('https://example.com')
+      end
+
+      it 'handles combined formatting' do
+        content = '**bold** _italic_ `code` [link](https://example.com)'
+        result = described_class.new(content, channel_type).render
+        expect(result.strip).to eq('*bold* _italic_ `code` https://example.com')
+      end
+
+      it 'handles nested formatting' do
+        content = '**bold _italic_**'
+        result = described_class.new(content, channel_type).render
+        expect(result.strip).to eq('*bold _italic_*')
+      end
+
+      it 'converts bullet lists' do
+        content = "- item 1\n- item 2"
+        result = described_class.new(content, channel_type).render
+        expect(result.strip).to include('- item 1')
+        expect(result.strip).to include('- item 2')
+        expect(result).to include("- item 1\n- item 2")
+      end
+
+      it 'preserves newlines in plain text without list markers' do
+        content = "Line 1\nLine 2\nLine 3"
+        result = described_class.new(content, channel_type).render
+        expect(result).to include("Line 1\nLine 2\nLine 3")
+        expect(result).not_to include('Line 1 Line 2')
+      end
+
+      it 'preserves multiple consecutive newlines for spacing' do
+        content = "Para 1\n\n\n\nPara 2"
+        result = described_class.new(content, channel_type).render
+        expect(result.scan("\n").count).to eq(4)
+        expect(result).to include("Para 1\n\n\n\nPara 2")
+      end
+    end
+
+    context 'when channel is Channel::Instagram' do
+      let(:channel_type) { 'Channel::Instagram' }
+
+      it 'converts bold from double to single asterisk' do
+        content = '**bold text**'
+        result = described_class.new(content, channel_type).render
+        expect(result.strip).to eq('*bold text*')
+      end
+
+      it 'keeps italic with underscore' do
+        content = '_italic text_'
+        result = described_class.new(content, channel_type).render
+        expect(result.strip).to eq('_italic text_')
+      end
+
+      it 'strips code backticks' do
+        content = '`code`'
+        result = described_class.new(content, channel_type).render
+        expect(result.strip).to eq('code')
+      end
+
+      it 'converts links to URLs only' do
+        content = '[link text](https://example.com)'
+        result = described_class.new(content, channel_type).render
+        expect(result.strip).to eq('https://example.com')
+      end
+
+      it 'preserves bullet list markers' do
+        content = "- first item\n- second item"
+        result = described_class.new(content, channel_type).render
+        expect(result).to include('- first item')
+        expect(result).to include('- second item')
+      end
+
+      it 'preserves ordered list markers with numbering' do
+        content = "1. first step\n2. second step"
+        result = described_class.new(content, channel_type).render
+        expect(result).to include('1. first step')
+        expect(result).to include('2. second step')
+      end
+
+      it 'preserves newlines in plain text without list markers' do
+        content = "Line 1\nLine 2\nLine 3"
+        result = described_class.new(content, channel_type).render
+        expect(result).to include("Line 1\nLine 2\nLine 3")
+        expect(result).not_to include('Line 1 Line 2')
+      end
+
+      it 'preserves multiple consecutive newlines for spacing' do
+        content = "Para 1\n\n\n\nPara 2"
+        result = described_class.new(content, channel_type).render
+        expect(result.scan("\n").count).to eq(4)
+        expect(result).to include("Para 1\n\n\n\nPara 2")
+      end
+    end
+
+    context 'when channel is Channel::Line' do
+      let(:channel_type) { 'Channel::Line' }
+
+      it 'adds spaces around bold markers' do
+        content = '**bold**'
+        result = described_class.new(content, channel_type).render
+        expect(result).to include(' *bold* ')
+      end
+
+      it 'adds spaces around italic markers' do
+        content = '_italic_'
+        result = described_class.new(content, channel_type).render
+        expect(result).to include(' _italic_ ')
+      end
+
+      it 'adds spaces around code markers' do
+        content = '`code`'
+        result = described_class.new(content, channel_type).render
+        expect(result).to include(' `code` ')
+      end
+    end
+
+    context 'when channel is Channel::Sms' do
+      let(:channel_type) { 'Channel::Sms' }
+
+      it 'strips all markdown formatting' do
+        content = '**bold** _italic_ `code`'
+        result = described_class.new(content, channel_type).render
+        expect(result.strip).to eq('bold italic code')
+      end
+
+      it 'preserves URLs from links in plain text format' do
+        content = '[link text](https://example.com)'
+        result = described_class.new(content, channel_type).render
+        expect(result).to eq('link text https://example.com')
+      end
+
+      it 'preserves URLs in messages with multiple links' do
+        content = 'Visit [our site](https://example.com) or [help center](https://help.example.com)'
+        result = described_class.new(content, channel_type).render
+        expect(result).to eq('Visit our site https://example.com or help center https://help.example.com')
+      end
+
+      it 'preserves link text and URL when both are present' do
+        content = '[Reset password](https://example.com/reset)'
+        result = described_class.new(content, channel_type).render
+        expect(result).to eq('Reset password https://example.com/reset')
+      end
+
+      it 'handles complex markdown' do
+        content = "# Heading\n\n**bold** _italic_ [link](https://example.com)"
+        result = described_class.new(content, channel_type).render
+        expect(result).to include('Heading')
+        expect(result).to include('bold')
+        expect(result).to include('italic')
+        expect(result).to include('link https://example.com')
+        expect(result).not_to include('**')
+        expect(result).not_to include('_')
+        expect(result).not_to include('[')
+      end
+
+      it 'preserves bullet list markers' do
+        content = "- first item\n- second item\n- third item"
+        result = described_class.new(content, channel_type).render
+        expect(result).to include('- first item')
+        expect(result).to include('- second item')
+        expect(result).to include('- third item')
+      end
+
+      it 'preserves ordered list markers with numbering' do
+        content = "1. first step\n2. second step\n3. third step"
+        result = described_class.new(content, channel_type).render
+        expect(result).to include('1. first step')
+        expect(result).to include('2. second step')
+        expect(result).to include('3. third step')
+      end
+
+      it 'preserves newlines in plain text without list markers' do
+        content = "Line 1\nLine 2\nLine 3"
+        result = described_class.new(content, channel_type).render
+        expect(result).to include("Line 1\nLine 2\nLine 3")
+        expect(result).not_to include('Line 1 Line 2')
+      end
+
+      it 'preserves multiple consecutive newlines for spacing' do
+        content = "Para 1\n\n\n\nPara 2"
+        result = described_class.new(content, channel_type).render
+        expect(result.scan("\n").count).to eq(4)
+        expect(result).to include("Para 1\n\n\n\nPara 2")
+      end
+    end
+
+    context 'when channel is Channel::Telegram' do
+      let(:channel_type) { 'Channel::Telegram' }
+
+      it 'converts to HTML format' do
+        content = '**bold** _italic_ `code`'
+        result = described_class.new(content, channel_type).render
+        expect(result).to include('<strong>bold</strong>')
+        expect(result).to include('<em>italic</em>')
+        expect(result).to include('<code>code</code>')
+      end
+
+      it 'handles links' do
+        content = '[link text](https://example.com)'
+        result = described_class.new(content, channel_type).render
+        expect(result).to include('<a href="https://example.com">link text</a>')
+      end
+
+      it 'preserves single newlines' do
+        content = "line 1\nline 2"
+        result = described_class.new(content, channel_type).render
+        expect(result).to include("\n")
+        expect(result).to include("line 1\nline 2")
+      end
+
+      it 'preserves double newlines (paragraph breaks)' do
+        content = "para 1\n\npara 2"
+        result = described_class.new(content, channel_type).render
+        expect(result.scan("\n").count).to eq(2)
+        expect(result).to include("para 1\n\npara 2")
+      end
+
+      it 'preserves multiple consecutive newlines' do
+        content = "para 1\n\n\n\npara 2"
+        result = described_class.new(content, channel_type).render
+        expect(result.scan("\n").count).to eq(4)
+        expect(result).to include("para 1\n\n\n\npara 2")
+      end
+
+      it 'preserves newlines with varying amounts of whitespace between them' do
+        # Test with 1 space, 3 spaces, 5 spaces, and tabs to ensure it handles any amount of whitespace
+        content = "hello\n \n   \n     \n\t\nworld"
+        result = described_class.new(content, channel_type).render
+        # Whitespace-only lines are normalized, so we should have at least 5 newlines preserved
+        expect(result.scan("\n").count).to be >= 5
+        expect(result).to include('hello')
+        expect(result).to include('world')
+        # Should not collapse to just 1-2 newlines
+        expect(result.scan("\n").count).to be > 3
+      end
+
+      it 'converts strikethrough to HTML' do
+        content = '~~strikethrough text~~'
+        result = described_class.new(content, channel_type).render
+        expect(result).to include('<del>strikethrough text</del>')
+      end
+
+      it 'converts blockquotes to HTML' do
+        content = '> quoted text'
+        result = described_class.new(content, channel_type).render
+        expect(result).to include('<blockquote>')
+        expect(result).to include('quoted text')
+      end
+    end
+
+    context 'when channel is Channel::Email' do
+      let(:channel_type) { 'Channel::Email' }
+
+      it 'renders full HTML' do
+        content = '**bold** _italic_'
+        result = described_class.new(content, channel_type).render
+        expect(result).to include('<strong>bold</strong>')
+        expect(result).to include('<em>italic</em>')
+      end
+
+      it 'renders ordered lists as HTML' do
+        content = "1. first\n2. second"
+        result = described_class.new(content, channel_type).render
+        expect(result).to include('<ol>')
+        expect(result).to include('<li>first</li>')
+      end
+
+      it 'converts strikethrough to HTML' do
+        content = '~~strikethrough text~~'
+        result = described_class.new(content, channel_type).render
+        expect(result).to include('<del>strikethrough text</del>')
+      end
+    end
+
+    context 'when channel is Channel::WebWidget' do
+      let(:channel_type) { 'Channel::WebWidget' }
+
+      it 'renders full HTML like Email' do
+        content = '**bold** _italic_ `code`'
+        result = described_class.new(content, channel_type).render
+        expect(result).to include('<strong>bold</strong>')
+        expect(result).to include('<em>italic</em>')
+        expect(result).to include('<code>code</code>')
+      end
+
+      it 'converts strikethrough to HTML' do
+        content = '~~strikethrough text~~'
+        result = described_class.new(content, channel_type).render
+        expect(result).to include('<del>strikethrough text</del>')
+      end
+    end
+
+    context 'when channel is Channel::FacebookPage' do
+      let(:channel_type) { 'Channel::FacebookPage' }
+
+      it 'converts bold to single asterisk like Instagram' do
+        content = '**bold text**'
+        result = described_class.new(content, channel_type).render
+        expect(result.strip).to eq('*bold text*')
+      end
+
+      it 'strips unsupported formatting' do
+        content = '`code` ~~strike~~'
+        result = described_class.new(content, channel_type).render
+        expect(result.strip).to eq('code ~~strike~~')
+      end
+
+      it 'preserves bullet list markers like Instagram' do
+        content = "- first item\n- second item"
+        result = described_class.new(content, channel_type).render
+        expect(result).to include('- first item')
+        expect(result).to include('- second item')
+      end
+
+      it 'preserves ordered list markers with numbering like Instagram' do
+        content = "1. first step\n2. second step"
+        result = described_class.new(content, channel_type).render
+        expect(result).to include('1. first step')
+        expect(result).to include('2. second step')
+      end
+    end
+
+    context 'when channel is Channel::TwilioSms' do
+      let(:channel_type) { 'Channel::TwilioSms' }
+
+      it 'strips all markdown like SMS when medium is sms' do
+        content = '**bold** _italic_'
+        channel = instance_double(Channel::TwilioSms, whatsapp?: false)
+        result = described_class.new(content, channel_type, channel).render
+        expect(result.strip).to eq('bold italic')
+      end
+
+      it 'uses WhatsApp renderer when medium is whatsapp' do
+        content = '**bold** _italic_ [link](https://example.com)'
+        channel = instance_double(Channel::TwilioSms, whatsapp?: true)
+        result = described_class.new(content, channel_type, channel).render
+        expect(result.strip).to eq('*bold* _italic_ https://example.com')
+      end
+
+      it 'preserves newlines in Twilio WhatsApp' do
+        content = "Line 1\nLine 2\nLine 3"
+        channel = instance_double(Channel::TwilioSms, whatsapp?: true)
+        result = described_class.new(content, channel_type, channel).render
+        expect(result).to include("Line 1\nLine 2\nLine 3")
+      end
+
+      it 'backwards compatible when channel is not provided' do
+        content = '**bold** _italic_'
+        result = described_class.new(content, channel_type).render
+        expect(result.strip).to eq('bold italic')
+      end
+    end
+
+    context 'when channel is Channel::Api' do
+      let(:channel_type) { 'Channel::Api' }
+
+      it 'preserves markdown as-is' do
+        content = '**bold** _italic_ `code`'
+        result = described_class.new(content, channel_type).render
+        expect(result).to eq('**bold** _italic_ `code`')
+      end
+
+      it 'preserves links with markdown syntax' do
+        content = '[Click here](https://example.com)'
+        result = described_class.new(content, channel_type).render
+        expect(result).to eq('[Click here](https://example.com)')
+      end
+
+      it 'preserves lists with markdown syntax' do
+        content = "- Item 1\n- Item 2"
+        result = described_class.new(content, channel_type).render
+        expect(result).to eq("- Item 1\n- Item 2")
+      end
+    end
+
+    context 'when channel is Channel::TwitterProfile' do
+      let(:channel_type) { 'Channel::TwitterProfile' }
+
+      it 'strips all markdown like SMS' do
+        content = '**bold** [link](https://example.com)'
+        result = described_class.new(content, channel_type).render
+        expect(result).to include('bold')
+        expect(result).to include('link https://example.com')
+        expect(result).not_to include('**')
+        expect(result).not_to include('[')
+      end
+
+      it 'preserves URLs from links' do
+        content = '[Reset password](https://example.com/reset)'
+        result = described_class.new(content, channel_type).render
+        expect(result).to eq('Reset password https://example.com/reset')
+      end
+    end
+
+    context 'when testing all formatting types' do
+      let(:channel_type) { 'Channel::Whatsapp' }
+
+      it 'handles ordered lists' do
+        content = "1. first\n2. second\n3. third"
+        result = described_class.new(content, channel_type).render
+        expect(result).to include('first')
+        expect(result).to include('second')
+        expect(result).to include('third')
+      end
+    end
+
+    context 'when channel is unknown' do
+      let(:channel_type) { 'Channel::Unknown' }
+
+      it 'returns content as-is' do
+        content = '**bold** _italic_'
+        result = described_class.new(content, channel_type).render
+        expect(result).to eq(content)
+      end
+    end
+
+    # Shared test for all text-based channels that preserve multiple newlines
+    # This tests the real-world scenario where frontend sends newlines with whitespace between them
+    context 'when content has multiple newlines with whitespace between them' do
+      # This mimics what frontends often send: newlines with spaces/tabs between them
+      let(:content_with_whitespace_newlines) { "hello   \n   \n   \n   \n   \n   \n   \n   \n   \n   \n   \n   \n   \n   \n   \n   \n \n\nhello wow" }
+
+      %w[
+        Channel::Telegram
+        Channel::Whatsapp
+        Channel::Instagram
+        Channel::FacebookPage
+        Channel::Line
+        Channel::Sms
+      ].each do |channel_type|
+        context "when channel is #{channel_type}" do
+          it 'normalizes whitespace-only lines and preserves multiple newlines' do
+            result = described_class.new(content_with_whitespace_newlines, channel_type).render
+            # Should preserve most of the newlines (at least 10+)
+            # The exact count may vary slightly by renderer, but should be significantly more than 1-2
+            expect(result.scan("\n").count).to be >= 10
+            # Should not collapse everything to just 1-2 newlines
+            expect(result.scan("\n").count).to be > 5
+          end
+        end
+      end
+
+      context 'when channel is Channel::TwilioSms with WhatsApp' do
+        it 'normalizes whitespace-only lines and preserves multiple newlines' do
+          channel = instance_double(Channel::TwilioSms, whatsapp?: true)
+          result = described_class.new(content_with_whitespace_newlines, 'Channel::TwilioSms', channel).render
+          expect(result.scan("\n").count).to be >= 10
+        end
+      end
+    end
+  end
+end
diff --git a/spec/services/whatsapp/csat_template_service_spec.rb b/spec/services/whatsapp/csat_template_service_spec.rb
new file mode 100644
index 000000000..f21d87227
--- /dev/null
+++ b/spec/services/whatsapp/csat_template_service_spec.rb
@@ -0,0 +1,376 @@
+require 'rails_helper'
+
+RSpec.describe Whatsapp::CsatTemplateService do
+  let(:account) { create(:account) }
+  let(:whatsapp_channel) do
+    create(:channel_whatsapp, account: account, provider: 'whatsapp_cloud', sync_templates: false, validate_provider_config: false)
+  end
+  let(:inbox) { create(:inbox, channel: whatsapp_channel, account: account) }
+  let(:service) { described_class.new(whatsapp_channel) }
+
+  let(:expected_template_name) { "customer_satisfaction_survey_#{whatsapp_channel.inbox.id}" }
+  let(:template_config) do
+    {
+      message: 'How would you rate your experience?',
+      button_text: 'Rate Us',
+      language: 'en',
+      base_url: 'https://example.com',
+      template_name: expected_template_name
+    }
+  end
+
+  before do
+    allow(ENV).to receive(:fetch).and_call_original
+    allow(ENV).to receive(:fetch).with('WHATSAPP_CLOUD_BASE_URL', anything).and_return('https://graph.facebook.com')
+  end
+
+  describe '#generate_template_name' do
+    context 'when no existing template' do
+      it 'returns base name as-is' do
+        whatsapp_channel.inbox.update!(csat_config: {})
+        result = service.send(:generate_template_name, 'new_template_name')
+        expect(result).to eq('new_template_name')
+      end
+
+      it 'returns base name when template key is missing' do
+        whatsapp_channel.inbox.update!(csat_config: { 'other_config' => 'value' })
+        result = service.send(:generate_template_name, 'new_template_name')
+        expect(result).to eq('new_template_name')
+      end
+    end
+
+    context 'when existing template has no versioned name' do
+      it 'starts versioning from 1' do
+        whatsapp_channel.inbox.update!(csat_config: {
+                                         'template' => { 'name' => expected_template_name }
+                                       })
+        result = service.send(:generate_template_name, 'new_template_name')
+        expect(result).to eq("#{expected_template_name}_1")
+      end
+
+      it 'starts versioning from 1 for custom name' do
+        whatsapp_channel.inbox.update!(csat_config: {
+                                         'template' => { 'name' => 'custom_survey' }
+                                       })
+        result = service.send(:generate_template_name, 'new_template_name')
+        expect(result).to eq("#{expected_template_name}_1")
+      end
+    end
+
+    context 'when existing template has versioned name' do
+      it 'increments version number' do
+        whatsapp_channel.inbox.update!(csat_config: {
+                                         'template' => { 'name' => "#{expected_template_name}_1" }
+                                       })
+        result = service.send(:generate_template_name, 'new_template_name')
+        expect(result).to eq("#{expected_template_name}_2")
+      end
+
+      it 'increments higher version numbers' do
+        whatsapp_channel.inbox.update!(csat_config: {
+                                         'template' => { 'name' => "#{expected_template_name}_5" }
+                                       })
+        result = service.send(:generate_template_name, 'new_template_name')
+        expect(result).to eq("#{expected_template_name}_6")
+      end
+
+      it 'handles double digit version numbers' do
+        whatsapp_channel.inbox.update!(csat_config: {
+                                         'template' => { 'name' => "#{expected_template_name}_12" }
+                                       })
+        result = service.send(:generate_template_name, 'new_template_name')
+        expect(result).to eq("#{expected_template_name}_13")
+      end
+    end
+
+    context 'when existing template has non-matching versioned name' do
+      it 'starts versioning from 1' do
+        whatsapp_channel.inbox.update!(csat_config: {
+                                         'template' => { 'name' => 'different_survey_3' }
+                                       })
+        result = service.send(:generate_template_name, 'new_template_name')
+        expect(result).to eq("#{expected_template_name}_1")
+      end
+    end
+
+    context 'when template name is blank' do
+      it 'returns base name' do
+        whatsapp_channel.inbox.update!(csat_config: {
+                                         'template' => { 'name' => '' }
+                                       })
+        result = service.send(:generate_template_name, 'new_template_name')
+        expect(result).to eq('new_template_name')
+      end
+
+      it 'returns base name when template name is nil' do
+        whatsapp_channel.inbox.update!(csat_config: {
+                                         'template' => { 'name' => nil }
+                                       })
+        result = service.send(:generate_template_name, 'new_template_name')
+        expect(result).to eq('new_template_name')
+      end
+    end
+  end
+
+  describe '#build_template_request_body' do
+    it 'builds correct request structure' do
+      result = service.send(:build_template_request_body, template_config)
+
+      expect(result).to eq({
+                             name: expected_template_name,
+                             language: 'en',
+                             category: 'MARKETING',
+                             components: [
+                               {
+                                 type: 'BODY',
+                                 text: 'How would you rate your experience?'
+                               },
+                               {
+                                 type: 'BUTTONS',
+                                 buttons: [
+                                   {
+                                     type: 'URL',
+                                     text: 'Rate Us',
+                                     url: 'https://example.com/survey/responses/{{1}}',
+                                     example: ['12345']
+                                   }
+                                 ]
+                               }
+                             ]
+                           })
+    end
+
+    it 'uses default language when not provided' do
+      config_without_language = template_config.except(:language)
+      result = service.send(:build_template_request_body, config_without_language)
+      expect(result[:language]).to eq('en')
+    end
+
+    it 'uses default button text when not provided' do
+      config_without_button = template_config.except(:button_text)
+      result = service.send(:build_template_request_body, config_without_button)
+      expect(result[:components][1][:buttons][0][:text]).to eq('Please rate us')
+    end
+  end
+
+  describe '#create_template' do
+    let(:mock_response) do
+      # rubocop:disable RSpec/VerifiedDoubles
+      double('response', :success? => true, :body => '{}', '[]' => { 'id' => '123', 'name' => 'template_name' })
+      # rubocop:enable RSpec/VerifiedDoubles
+    end
+
+    before do
+      allow(HTTParty).to receive(:post).and_return(mock_response)
+      inbox.update!(csat_config: {})
+    end
+
+    it 'creates template with generated name' do
+      expected_body = {
+        name: expected_template_name,
+        language: 'en',
+        category: 'MARKETING',
+        components: [
+          {
+            type: 'BODY',
+            text: 'How would you rate your experience?'
+          },
+          {
+            type: 'BUTTONS',
+            buttons: [
+              {
+                type: 'URL',
+                text: 'Rate Us',
+                url: 'https://example.com/survey/responses/{{1}}',
+                example: ['12345']
+              }
+            ]
+          }
+        ]
+      }
+
+      expect(HTTParty).to receive(:post).with(
+        "https://graph.facebook.com/v14.0/#{whatsapp_channel.provider_config['business_account_id']}/message_templates",
+        headers: {
+          'Authorization' => "Bearer #{whatsapp_channel.provider_config['api_key']}",
+          'Content-Type' => 'application/json'
+        },
+        body: expected_body.to_json
+      )
+
+      service.create_template(template_config)
+    end
+
+    it 'returns success response on successful creation' do
+      allow(mock_response).to receive(:[]).with('id').and_return('template_123')
+      allow(mock_response).to receive(:[]).with('name').and_return(expected_template_name)
+
+      result = service.create_template(template_config)
+
+      expect(result).to eq({
+                             success: true,
+                             template_id: 'template_123',
+                             template_name: expected_template_name,
+                             language: 'en',
+                             status: 'PENDING'
+                           })
+    end
+
+    context 'when API call fails' do
+      let(:error_response) do
+        # rubocop:disable RSpec/VerifiedDoubles
+        double('response', success?: false, code: 400, body: '{"error": "Invalid template"}')
+        # rubocop:enable RSpec/VerifiedDoubles
+      end
+
+      before do
+        allow(HTTParty).to receive(:post).and_return(error_response)
+        allow(Rails.logger).to receive(:error)
+      end
+
+      it 'returns error response' do
+        result = service.create_template(template_config)
+
+        expect(result).to eq({
+                               success: false,
+                               error: 'Template creation failed',
+                               response_body: '{"error": "Invalid template"}'
+                             })
+      end
+
+      it 'logs the error' do
+        expect(Rails.logger).to receive(:error).with('WhatsApp template creation failed: 400 - {"error": "Invalid template"}')
+        service.create_template(template_config)
+      end
+    end
+  end
+
+  describe '#delete_template' do
+    it 'makes DELETE request to correct endpoint' do
+      # rubocop:disable RSpec/VerifiedDoubles
+      mock_response = double('response', success?: true, body: '{}')
+      # rubocop:enable RSpec/VerifiedDoubles
+
+      expect(HTTParty).to receive(:delete).with(
+        "https://graph.facebook.com/v14.0/#{whatsapp_channel.provider_config['business_account_id']}/message_templates?name=test_template",
+        headers: {
+          'Authorization' => "Bearer #{whatsapp_channel.provider_config['api_key']}",
+          'Content-Type' => 'application/json'
+        }
+      ).and_return(mock_response)
+
+      result = service.delete_template('test_template')
+      expect(result).to eq({ success: true, response_body: '{}' })
+    end
+
+    it 'uses default template name when none provided' do
+      # rubocop:disable RSpec/VerifiedDoubles
+      mock_response = double('response', success?: true, body: '{}')
+      # rubocop:enable RSpec/VerifiedDoubles
+
+      expect(HTTParty).to receive(:delete).with(
+        "https://graph.facebook.com/v14.0/#{whatsapp_channel.provider_config['business_account_id']}/message_templates?name=#{expected_template_name}",
+        anything
+      ).and_return(mock_response)
+
+      service.delete_template
+    end
+
+    it 'returns failure response when API call fails' do
+      # rubocop:disable RSpec/VerifiedDoubles
+      mock_response = double('response', success?: false, body: '{"error": "Template not found"}')
+      # rubocop:enable RSpec/VerifiedDoubles
+      allow(HTTParty).to receive(:delete).and_return(mock_response)
+
+      result = service.delete_template('test_template')
+      expect(result).to eq({ success: false, response_body: '{"error": "Template not found"}' })
+    end
+  end
+
+  describe '#get_template_status' do
+    it 'makes GET request to correct endpoint' do
+      # rubocop:disable RSpec/VerifiedDoubles
+      mock_response = double('response', success?: true, body: '{}')
+      # rubocop:enable RSpec/VerifiedDoubles
+      allow(mock_response).to receive(:[]).with('data').and_return([{
+                                                                     'id' => '123',
+                                                                     'name' => 'test_template',
+                                                                     'status' => 'APPROVED',
+                                                                     'language' => 'en'
+                                                                   }])
+
+      expect(HTTParty).to receive(:get).with(
+        "https://graph.facebook.com/v14.0/#{whatsapp_channel.provider_config['business_account_id']}/message_templates?name=test_template",
+        headers: {
+          'Authorization' => "Bearer #{whatsapp_channel.provider_config['api_key']}",
+          'Content-Type' => 'application/json'
+        }
+      ).and_return(mock_response)
+
+      service.get_template_status('test_template')
+    end
+
+    it 'returns success response when template exists' do
+      # rubocop:disable RSpec/VerifiedDoubles
+      mock_response = double('response', success?: true, body: '{}')
+      # rubocop:enable RSpec/VerifiedDoubles
+      allow(mock_response).to receive(:[]).with('data').and_return([{
+                                                                     'id' => '123',
+                                                                     'name' => 'test_template',
+                                                                     'status' => 'APPROVED',
+                                                                     'language' => 'en'
+                                                                   }])
+      allow(HTTParty).to receive(:get).and_return(mock_response)
+
+      result = service.get_template_status('test_template')
+
+      expect(result).to eq({
+                             success: true,
+                             template: {
+                               id: '123',
+                               name: 'test_template',
+                               status: 'APPROVED',
+                               language: 'en'
+                             }
+                           })
+    end
+
+    it 'returns failure response when template not found' do
+      # rubocop:disable RSpec/VerifiedDoubles
+      mock_response = double('response', success?: true, body: '{}')
+      # rubocop:enable RSpec/VerifiedDoubles
+      allow(mock_response).to receive(:[]).with('data').and_return([])
+      allow(HTTParty).to receive(:get).and_return(mock_response)
+
+      result = service.get_template_status('test_template')
+      expect(result).to eq({ success: false, error: 'Template not found' })
+    end
+
+    it 'returns failure response when API call fails' do
+      # rubocop:disable RSpec/VerifiedDoubles
+      mock_response = double('response', success?: false, body: '{}')
+      # rubocop:enable RSpec/VerifiedDoubles
+      allow(HTTParty).to receive(:get).and_return(mock_response)
+
+      result = service.get_template_status('test_template')
+      expect(result).to eq({ success: false, error: 'Template not found' })
+    end
+
+    context 'when API raises an exception' do
+      before do
+        allow(HTTParty).to receive(:get).and_raise(StandardError, 'Network error')
+        allow(Rails.logger).to receive(:error)
+      end
+
+      it 'handles exceptions gracefully' do
+        result = service.get_template_status('test_template')
+        expect(result).to eq({ success: false, error: 'Network error' })
+      end
+
+      it 'logs the error' do
+        expect(Rails.logger).to receive(:error).with('Error fetching template status: Network error')
+        service.get_template_status('test_template')
+      end
+    end
+  end
+end
diff --git a/spec/services/whatsapp/providers/whatsapp_cloud_service_spec.rb b/spec/services/whatsapp/providers/whatsapp_cloud_service_spec.rb
index 69ba69379..156e46349 100644
--- a/spec/services/whatsapp/providers/whatsapp_cloud_service_spec.rb
+++ b/spec/services/whatsapp/providers/whatsapp_cloud_service_spec.rb
@@ -312,4 +312,92 @@ describe Whatsapp::Providers::WhatsappCloudService do
       end
     end
   end
+
+  describe 'CSAT template methods' do
+    let(:mock_csat_template_service) { instance_double(Whatsapp::CsatTemplateService) }
+    let(:expected_template_name) { "customer_satisfaction_survey_#{whatsapp_channel.inbox.id}" }
+    let(:template_config) do
+      {
+        name: expected_template_name,
+        language: 'en',
+        category: 'UTILITY'
+      }
+    end
+
+    before do
+      allow(Whatsapp::CsatTemplateService).to receive(:new)
+        .with(whatsapp_channel)
+        .and_return(mock_csat_template_service)
+    end
+
+    describe '#create_csat_template' do
+      it 'delegates to csat_template_service with correct config' do
+        allow(mock_csat_template_service).to receive(:create_template)
+          .with(template_config)
+          .and_return({ success: true, template_id: '123' })
+
+        result = service.create_csat_template(template_config)
+
+        expect(mock_csat_template_service).to have_received(:create_template).with(template_config)
+        expect(result).to eq({ success: true, template_id: '123' })
+      end
+    end
+
+    describe '#delete_csat_template' do
+      it 'delegates to csat_template_service with default template name' do
+        allow(mock_csat_template_service).to receive(:delete_template)
+          .with(expected_template_name)
+          .and_return({ success: true })
+
+        result = service.delete_csat_template
+
+        expect(mock_csat_template_service).to have_received(:delete_template).with(expected_template_name)
+        expect(result).to eq({ success: true })
+      end
+
+      it 'delegates to csat_template_service with custom template name' do
+        custom_template_name = 'custom_csat_template'
+        allow(mock_csat_template_service).to receive(:delete_template)
+          .with(custom_template_name)
+          .and_return({ success: true })
+
+        result = service.delete_csat_template(custom_template_name)
+
+        expect(mock_csat_template_service).to have_received(:delete_template).with(custom_template_name)
+        expect(result).to eq({ success: true })
+      end
+    end
+
+    describe '#get_template_status' do
+      it 'delegates to csat_template_service with template name' do
+        template_name = 'customer_survey_template'
+        expected_response = { success: true, template: { status: 'APPROVED' } }
+        allow(mock_csat_template_service).to receive(:get_template_status)
+          .with(template_name)
+          .and_return(expected_response)
+
+        result = service.get_template_status(template_name)
+
+        expect(mock_csat_template_service).to have_received(:get_template_status).with(template_name)
+        expect(result).to eq(expected_response)
+      end
+    end
+
+    describe 'csat_template_service memoization' do
+      it 'creates and memoizes the csat_template_service instance' do
+        allow(Whatsapp::CsatTemplateService).to receive(:new)
+          .with(whatsapp_channel)
+          .and_return(mock_csat_template_service)
+        allow(mock_csat_template_service).to receive(:get_template_status)
+          .and_return({ success: true })
+
+        # Call multiple methods that use the service
+        service.get_template_status('test1')
+        service.get_template_status('test2')
+
+        # Verify the service was only instantiated once
+        expect(Whatsapp::CsatTemplateService).to have_received(:new).once
+      end
+    end
+  end
 end