Initial commit: Add logistics and order_detail message types

- Add Logistics component with progress tracking
- Add OrderDetail component for order information
- Support data-driven steps and actions
- Add blue color scale to widget SCSS
- Fix node overflow and progress bar rendering issues
- Add English translations for dashboard components

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

spec/enterprise/jobs/captain/conversation/response_builder_job_spec.rb

@@ -0,0 +1,334 @@
+require 'rails_helper'
+
+RSpec.describe Captain::Conversation::ResponseBuilderJob, type: :job do
+  let(:account) { create(:account, custom_attributes: { plan_name: 'startups' }) }
+  let(:inbox) { create(:inbox, account: account) }
+  let(:assistant) { create(:captain_assistant, account: account) }
+  let(:captain_inbox_association) { create(:captain_inbox, captain_assistant: assistant, inbox: inbox) }
+
+  describe '#perform' do
+    let(:conversation) { create(:conversation, inbox: inbox, account: account) }
+    let(:mock_llm_chat_service) { instance_double(Captain::Llm::AssistantChatService) }
+    let(:mock_agent_runner_service) { instance_double(Captain::Assistant::AgentRunnerService) }
+
+    before do
+      create(:message, conversation: conversation, content: 'Hello', message_type: :incoming)
+
+      allow(inbox).to receive(:captain_active?).and_return(true)
+      allow(Captain::Llm::AssistantChatService).to receive(:new).and_return(mock_llm_chat_service)
+      allow(mock_llm_chat_service).to receive(:generate_response).and_return({ 'response' => 'Hey, welcome to Captain Specs' })
+      allow(Captain::Assistant::AgentRunnerService).to receive(:new).and_return(mock_agent_runner_service)
+      allow(mock_agent_runner_service).to receive(:generate_response).and_return({ 'response' => 'Hey, welcome to Captain V2' })
+    end
+
+    context 'when captain_v2 is disabled' do
+      before do
+        allow(account).to receive(:feature_enabled?).and_return(false)
+        allow(account).to receive(:feature_enabled?).with('captain_integration_v2').and_return(false)
+      end
+
+      it 'uses Captain::Llm::AssistantChatService' do
+        expect(Captain::Llm::AssistantChatService).to receive(:new).with(assistant: assistant, conversation_id: conversation.display_id)
+        expect(Captain::Assistant::AgentRunnerService).not_to receive(:new)
+
+        described_class.perform_now(conversation, assistant)
+        expect(conversation.messages.last.content).to eq('Hey, welcome to Captain Specs')
+      end
+
+      it 'generates and processes response' do
+        described_class.perform_now(conversation, assistant)
+        expect(conversation.messages.count).to eq(2)
+        expect(conversation.messages.outgoing.count).to eq(1)
+        expect(conversation.messages.last.content).to eq('Hey, welcome to Captain Specs')
+      end
+
+      it 'increments usage response' do
+        described_class.perform_now(conversation, assistant)
+        account.reload
+        expect(account.usage_limits[:captain][:responses][:consumed]).to eq(1)
+      end
+    end
+
+    context 'when captain_v2 is enabled' do
+      before do
+        allow(account).to receive(:feature_enabled?).and_return(false)
+        allow(account).to receive(:feature_enabled?).with('captain_integration_v2').and_return(true)
+      end
+
+      it 'uses Captain::Assistant::AgentRunnerService' do
+        expect(Captain::Assistant::AgentRunnerService).to receive(:new).with(
+          assistant: assistant,
+          conversation: conversation
+        )
+        expect(Captain::Llm::AssistantChatService).not_to receive(:new)
+
+        described_class.perform_now(conversation, assistant)
+        expect(conversation.messages.last.content).to eq('Hey, welcome to Captain V2')
+      end
+
+      it 'passes message history to agent runner service' do
+        expected_messages = [
+          { content: 'Hello', role: 'user' }
+        ]
+
+        expect(mock_agent_runner_service).to receive(:generate_response).with(
+          message_history: expected_messages
+        )
+
+        described_class.perform_now(conversation, assistant)
+      end
+
+      it 'generates and processes response' do
+        described_class.perform_now(conversation, assistant)
+        expect(conversation.messages.count).to eq(2)
+        expect(conversation.messages.outgoing.count).to eq(1)
+        expect(conversation.messages.last.content).to eq('Hey, welcome to Captain V2')
+      end
+
+      it 'increments usage response' do
+        described_class.perform_now(conversation, assistant)
+        account.reload
+        expect(account.usage_limits[:captain][:responses][:consumed]).to eq(1)
+      end
+    end
+
+    context 'when message contains an image' do
+      let(:message_with_image) { create(:message, conversation: conversation, message_type: :incoming, content: 'Can you help with this error?') }
+      let(:image_attachment) { message_with_image.attachments.create!(account: account, file_type: :image, external_url: 'https://example.com/error.jpg') }
+
+      before do
+        image_attachment
+      end
+
+      it 'includes image URL directly in the message content for OpenAI vision analysis' do
+        # Expect the generate_response to receive multimodal content with image URL
+        expect(mock_llm_chat_service).to receive(:generate_response) do |**kwargs|
+          history = kwargs[:message_history]
+          last_entry = history.last
+          expect(last_entry[:content]).to be_an(Array)
+          expect(last_entry[:content].any? { |part| part[:type] == 'text' && part[:text] == 'Can you help with this error?' }).to be true
+          expect(last_entry[:content].any? do |part|
+            part[:type] == 'image_url' && part[:image_url][:url] == 'https://example.com/error.jpg'
+          end).to be true
+          { 'response' => 'I can see the error in your image. It appears to be a database connection issue.' }
+        end
+
+        described_class.perform_now(conversation, assistant)
+      end
+    end
+  end
+
+  describe 'retry mechanisms for image processing' do
+    let(:conversation) { create(:conversation, inbox: inbox, account: account) }
+    let(:mock_llm_chat_service) { instance_double(Captain::Llm::AssistantChatService) }
+    let(:mock_message_builder) { instance_double(Captain::OpenAiMessageBuilderService) }
+
+    before do
+      create(:message, conversation: conversation, content: 'Hello with image', message_type: :incoming)
+      allow(Captain::Llm::AssistantChatService).to receive(:new).and_return(mock_llm_chat_service)
+      allow(Captain::OpenAiMessageBuilderService).to receive(:new).with(message: anything).and_return(mock_message_builder)
+      allow(mock_message_builder).to receive(:generate_content).and_return('Hello with image')
+      allow(mock_llm_chat_service).to receive(:generate_response).and_return({ 'response' => 'Test response' })
+    end
+
+    context 'when ActiveStorage::FileNotFoundError occurs' do
+      it 'handles file errors and triggers handoff' do
+        allow(mock_message_builder).to receive(:generate_content)
+          .and_raise(ActiveStorage::FileNotFoundError, 'Image file not found')
+
+        # For retryable errors, the job should handle them and proceed with handoff
+        described_class.perform_now(conversation, assistant)
+
+        # Verify handoff occurred due to repeated failures
+        expect(conversation.reload.status).to eq('open')
+      end
+
+      it 'succeeds when no error occurs' do
+        # Don't raise any error, should succeed normally
+        allow(mock_message_builder).to receive(:generate_content)
+          .and_return('Image content processed successfully')
+
+        described_class.perform_now(conversation, assistant)
+
+        expect(conversation.messages.outgoing.count).to eq(1)
+        expect(conversation.messages.outgoing.last.content).to eq('Test response')
+      end
+    end
+
+    context 'when Faraday::BadRequestError occurs' do
+      it 'handles API errors and triggers handoff' do
+        allow(mock_llm_chat_service).to receive(:generate_response)
+          .and_raise(Faraday::BadRequestError, 'Bad request to image service')
+
+        described_class.perform_now(conversation, assistant)
+        expect(conversation.reload.status).to eq('open')
+      end
+
+      it 'succeeds when no error occurs' do
+        # Don't raise any error, should succeed normally
+        allow(mock_llm_chat_service).to receive(:generate_response)
+          .and_return({ 'response' => 'Response after retry' })
+
+        described_class.perform_now(conversation, assistant)
+
+        expect(conversation.messages.outgoing.last.content).to eq('Response after retry')
+      end
+    end
+
+    context 'when image processing fails permanently' do
+      before do
+        allow(mock_message_builder).to receive(:generate_content)
+          .and_raise(ActiveStorage::FileNotFoundError, 'Image permanently unavailable')
+      end
+
+      it 'triggers handoff after max retries' do
+        # Since perform_now re-raises retryable errors, simulate the final failure after retries
+        allow(mock_message_builder).to receive(:generate_content)
+          .and_raise(StandardError, 'Max retries exceeded')
+
+        expect(ChatwootExceptionTracker).to receive(:new).and_call_original
+
+        described_class.perform_now(conversation, assistant)
+
+        expect(conversation.reload.status).to eq('open')
+      end
+    end
+
+    context 'when non-retryable error occurs' do
+      let(:standard_error) { StandardError.new('Generic error') }
+
+      before do
+        allow(mock_llm_chat_service).to receive(:generate_response).and_raise(standard_error)
+      end
+
+      it 'handles error and triggers handoff' do
+        expect(ChatwootExceptionTracker).to receive(:new)
+          .with(standard_error, account: account)
+          .and_call_original
+
+        described_class.perform_now(conversation, assistant)
+
+        expect(conversation.reload.status).to eq('open')
+      end
+
+      it 'ensures Current.executed_by is reset' do
+        expect(Current).to receive(:executed_by=).with(assistant)
+        expect(Current).to receive(:executed_by=).with(nil)
+
+        described_class.perform_now(conversation, assistant)
+      end
+    end
+  end
+
+  describe 'job configuration' do
+    it 'has retry_on configuration for retryable errors' do
+      expect(described_class).to respond_to(:retry_on)
+    end
+
+    it 'defines MAX_MESSAGE_LENGTH constant' 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

spec/enterprise/jobs/captain/copilot/response_job_spec.rb

@@ -0,0 +1,45 @@
+require 'rails_helper'
+
+RSpec.describe Captain::Copilot::ResponseJob, type: :job do
+  let(:account) { create(:account) }
+  let(:user) { create(:user, account: account) }
+  let(:assistant) { create(:captain_assistant, account: account) }
+  let(:copilot_thread) { create(:captain_copilot_thread, account: account, user: user, assistant: assistant) }
+  let(:conversation_id) { 123 }
+  let(:message) { { 'content' => 'Test message' } }
+
+  describe '#perform' do
+    let(:chat_service) { instance_double(Captain::Copilot::ChatService) }
+
+    before do
+      allow(Captain::Copilot::ChatService).to receive(:new).with(
+        assistant,
+        user_id: user.id,
+        copilot_thread_id: copilot_thread.id,
+        conversation_id: conversation_id
+      ).and_return(chat_service)
+      # When copilot_thread_id is present, message is already in previous_history
+      # so nil is passed to avoid duplicate
+      allow(chat_service).to receive(:generate_response).with(nil)
+    end
+
+    it 'initializes ChatService with correct parameters and calls generate_response' do
+      expect(Captain::Copilot::ChatService).to receive(:new).with(
+        assistant,
+        user_id: user.id,
+        copilot_thread_id: copilot_thread.id,
+        conversation_id: conversation_id
+      )
+      # Message is already persisted in copilot_thread.previous_history,
+      # so we pass nil to prevent duplicate user messages
+      expect(chat_service).to receive(:generate_response).with(nil)
+      described_class.perform_now(
+        assistant: assistant,
+        conversation_id: conversation_id,
+        user_id: user.id,
+        copilot_thread_id: copilot_thread.id,
+        message: message
+      )
+    end
+  end
+end

spec/enterprise/jobs/captain/documents/crawl_job_spec.rb

@@ -0,0 +1,133 @@
+require 'rails_helper'
+
+RSpec.describe Captain::Documents::CrawlJob, type: :job do
+  let(:document) { create(:captain_document, external_link: 'https://example.com/page') }
+  let(:assistant_id) { document.assistant_id }
+  let(:webhook_url) { Rails.application.routes.url_helpers.enterprise_webhooks_firecrawl_url }
+
+  describe '#perform' do
+    context 'when CAPTAIN_FIRECRAWL_API_KEY is configured' do
+      let(:firecrawl_service) { instance_double(Captain::Tools::FirecrawlService) }
+      let(:account) { document.account }
+      let(:token) { Digest::SHA256.hexdigest("-key#{document.assistant_id}#{document.account_id}") }
+
+      before do
+        allow(Captain::Tools::FirecrawlService).to receive(:new).and_return(firecrawl_service)
+        allow(firecrawl_service).to receive(:perform)
+        create(:installation_config, name: 'CAPTAIN_FIRECRAWL_API_KEY', value: 'test-key')
+      end
+
+      context 'with account usage limits' do
+        before do
+          allow(account).to receive(:usage_limits).and_return({ captain: { documents: { current_available: 20 } } })
+        end
+
+        it 'uses FirecrawlService with the correct crawl limit' do
+          expect(firecrawl_service).to receive(:perform).with(
+            document.external_link,
+            "#{webhook_url}?assistant_id=#{assistant_id}&token=#{token}",
+            20
+          )
+
+          described_class.perform_now(document)
+        end
+      end
+
+      context 'when crawl limit exceeds maximum' do
+        before do
+          allow(account).to receive(:usage_limits).and_return({ captain: { documents: { current_available: 1000 } } })
+        end
+
+        it 'caps the crawl limit at 500' do
+          expect(firecrawl_service).to receive(:perform).with(
+            document.external_link,
+            "#{webhook_url}?assistant_id=#{assistant_id}&token=#{token}",
+            500
+          )
+
+          described_class.perform_now(document)
+        end
+      end
+
+      context 'with no usage limits configured' do
+        before do
+          allow(account).to receive(:usage_limits).and_return({})
+        end
+
+        it 'uses default crawl limit of 10' do
+          expect(firecrawl_service).to receive(:perform).with(
+            document.external_link,
+            "#{webhook_url}?assistant_id=#{assistant_id}&token=#{token}",
+            10
+          )
+
+          described_class.perform_now(document)
+        end
+      end
+    end
+
+    context 'when CAPTAIN_FIRECRAWL_API_KEY is not configured' do
+      let(:page_links) { ['https://example.com/page1', 'https://example.com/page2'] }
+      let(:simple_crawler) { instance_double(Captain::Tools::SimplePageCrawlService) }
+
+      before do
+        allow(Captain::Tools::SimplePageCrawlService)
+          .to receive(:new)
+          .with(document.external_link)
+          .and_return(simple_crawler)
+
+        allow(simple_crawler).to receive(:page_links).and_return(page_links)
+      end
+
+      it 'enqueues SimplePageCrawlParserJob for each discovered link' do
+        page_links.each do |link|
+          expect(Captain::Tools::SimplePageCrawlParserJob)
+            .to receive(:perform_later)
+            .with(
+              assistant_id: assistant_id,
+              page_link: link
+            )
+        end
+
+        # Should also crawl the original link
+        expect(Captain::Tools::SimplePageCrawlParserJob)
+          .to receive(:perform_later)
+          .with(
+            assistant_id: assistant_id,
+            page_link: document.external_link
+          )
+
+        described_class.perform_now(document)
+      end
+
+      it 'uses SimplePageCrawlService to discover page links' do
+        expect(simple_crawler).to receive(:page_links)
+        described_class.perform_now(document)
+      end
+    end
+
+    context 'when document is a PDF' do
+      let(:pdf_document) do
+        doc = create(:captain_document, external_link: 'https://example.com/document')
+        allow(doc).to receive(:pdf_document?).and_return(true)
+        allow(doc).to receive(:update!).and_return(true)
+        doc
+      end
+
+      it 'processes PDF using PdfProcessingService' do
+        pdf_service = instance_double(Captain::Llm::PdfProcessingService)
+        expect(Captain::Llm::PdfProcessingService).to receive(:new).with(pdf_document).and_return(pdf_service)
+        expect(pdf_service).to receive(:process)
+        expect(pdf_document).to receive(:update!).with(status: :available)
+
+        described_class.perform_now(pdf_document)
+      end
+
+      it 'handles PDF processing errors' do
+        allow(Captain::Llm::PdfProcessingService).to receive(:new).and_raise(StandardError, 'Processing failed')
+
+        expect { described_class.perform_now(pdf_document) }.to raise_error(StandardError, 'Processing failed')
+      end
+    end
+  end
+end

spec/enterprise/jobs/captain/documents/response_builder_job_spec.rb

@@ -0,0 +1,104 @@
+require 'rails_helper'
+
+RSpec.describe Captain::Documents::ResponseBuilderJob, type: :job do
+  let(:assistant) { create(:captain_assistant) }
+  let(:document) { create(:captain_document, assistant: assistant) }
+  let(:faq_generator) { instance_double(Captain::Llm::FaqGeneratorService) }
+  let(:faqs) do
+    [
+      { 'question' => 'What is Ruby?', 'answer' => 'A programming language' },
+      { 'question' => 'What is Rails?', 'answer' => 'A web framework' }
+    ]
+  end
+
+  before do
+    allow(Captain::Llm::FaqGeneratorService).to receive(:new)
+      .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
+
+  describe '#perform' do
+    context 'when processing a document' do
+      it 'deletes previous responses' do
+        existing_response = create(:captain_assistant_response, documentable: document)
+
+        described_class.new.perform(document)
+
+        expect { existing_response.reload }.to raise_error(ActiveRecord::RecordNotFound)
+      end
+
+      it 'creates new responses for each FAQ' do
+        expect do
+          described_class.new.perform(document)
+        end.to change(Captain::AssistantResponse, :count).by(2)
+
+        responses = document.responses.reload
+        expect(responses.count).to eq(2)
+
+        first_response = responses.first
+        expect(first_response.question).to eq('What is Ruby?')
+        expect(first_response.answer).to eq('A programming language')
+        expect(first_response.assistant).to eq(assistant)
+        expect(first_response.documentable).to eq(document)
+      end
+    end
+
+    context 'with different locales' do
+      let(:spanish_account) { create(:account, locale: 'pt') }
+      let(:spanish_assistant) { create(:captain_assistant, account: spanish_account) }
+      let(:spanish_document) { create(:captain_document, assistant: spanish_assistant, account: spanish_account) }
+      let(:spanish_faq_generator) { instance_double(Captain::Llm::FaqGeneratorService) }
+
+      before do
+        allow(Captain::Llm::FaqGeneratorService).to receive(:new)
+          .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
+
+      it 'passes the correct locale to FAQ generator' do
+        described_class.new.perform(spanish_document)
+
+        expect(Captain::Llm::FaqGeneratorService).to have_received(:new)
+          .with(spanish_document.content, 'portuguese', account_id: spanish_document.account_id)
+      end
+    end
+
+    context 'when processing a PDF document' do
+      let(:pdf_document) do
+        doc = create(:captain_document, assistant: assistant)
+        allow(doc).to receive(:pdf_document?).and_return(true)
+        allow(doc).to receive(:openai_file_id).and_return('file-123')
+        allow(doc).to receive(:update!).and_return(true)
+        allow(doc).to receive(:metadata).and_return({})
+        doc
+      end
+      let(:paginated_service) { instance_double(Captain::Llm::PaginatedFaqGeneratorService) }
+      let(:pdf_faqs) do
+        [{ 'question' => 'What is in the PDF?', 'answer' => 'Important content' }]
+      end
+
+      before do
+        allow(Captain::Llm::PaginatedFaqGeneratorService).to receive(:new)
+          .with(pdf_document, anything)
+          .and_return(paginated_service)
+        allow(paginated_service).to receive(:generate).and_return(pdf_faqs)
+        allow(paginated_service).to receive(:total_pages_processed).and_return(10)
+        allow(paginated_service).to receive(:iterations_completed).and_return(1)
+      end
+
+      it 'uses paginated FAQ generator for PDFs' do
+        expect(Captain::Llm::PaginatedFaqGeneratorService).to receive(:new).with(pdf_document, anything)
+
+        described_class.new.perform(pdf_document)
+      end
+
+      it 'stores pagination metadata' do
+        expect(pdf_document).to receive(:update!).with(hash_including(metadata: hash_including('faq_generation')))
+
+        described_class.new.perform(pdf_document)
+      end
+    end
+  end
+end

spec/enterprise/jobs/captain/inbox_pending_conversations_resolution_job_spec.rb

@@ -0,0 +1,67 @@
+require 'rails_helper'
+
+RSpec.describe Captain::InboxPendingConversationsResolutionJob, type: :job do
+  let!(:inbox) { create(:inbox) }
+
+  let!(:resolvable_pending_conversation) { create(:conversation, inbox: inbox, last_activity_at: 2.hours.ago, status: :pending) }
+  let!(:recent_pending_conversation) { create(:conversation, inbox: inbox, last_activity_at: 10.minutes.ago, status: :pending) }
+  let!(:open_conversation) { create(:conversation, inbox: inbox, last_activity_at: 1.hour.ago, status: :open) }
+
+  let!(:captain_assistant) { create(:captain_assistant, account: inbox.account) }
+
+  before do
+    create(:captain_inbox, inbox: inbox, captain_assistant: captain_assistant)
+    stub_const('Limits::BULK_ACTIONS_LIMIT', 2)
+    inbox.reload
+  end
+
+  it 'queues the job' do
+    expect { described_class.perform_later(inbox) }
+      .to have_enqueued_job.on_queue('low')
+  end
+
+  it 'resolves only the eligible pending conversations' do
+    described_class.perform_now(inbox)
+
+    expect(resolvable_pending_conversation.reload.status).to eq('resolved')
+    expect(recent_pending_conversation.reload.status).to eq('pending')
+    expect(open_conversation.reload.status).to eq('open')
+  end
+
+  it 'creates exactly one outgoing message with configured content' do
+    custom_message = 'This is a custom resolution message.'
+    captain_assistant.update!(config: { 'resolution_message' => custom_message })
+
+    expect do
+      described_class.perform_now(inbox)
+    end.to change { resolvable_pending_conversation.messages.outgoing.reload.count }.by(1)
+
+    outgoing_message = resolvable_pending_conversation.messages.outgoing.last
+    expect(outgoing_message.content).to eq(custom_message)
+  end
+
+  it 'creates an outgoing message with default auto resolution message if not configured' do
+    captain_assistant.update!(config: {})
+
+    described_class.perform_now(inbox)
+    outgoing_message = resolvable_pending_conversation.messages.outgoing.last
+    expect(outgoing_message.content).to eq(
+      I18n.t('conversations.activity.auto_resolution_message')
+    )
+  end
+
+  it 'adds the correct activity message after resolution by Captain' do
+    described_class.perform_now(inbox)
+    expected_content = I18n.t('conversations.activity.captain.resolved', user_name: captain_assistant.name)
+    expect(Conversations::ActivityMessageJob)
+      .to have_been_enqueued.with(
+        resolvable_pending_conversation,
+        {
+          account_id: resolvable_pending_conversation.account_id,
+          inbox_id: resolvable_pending_conversation.inbox_id,
+          message_type: :activity,
+          content: expected_content
+        }
+      )
+  end
+end

spec/enterprise/jobs/captain/tools/firecrawl_parser_job_spec.rb

@@ -0,0 +1,64 @@
+require 'rails_helper'
+
+RSpec.describe Captain::Tools::FirecrawlParserJob, type: :job do
+  describe '#perform' do
+    let(:assistant) { create(:captain_assistant) }
+    let(:payload) do
+      {
+        markdown: 'Launch Week I is here! 🚀',
+        metadata: {
+          'title' => 'Home - Firecrawl',
+          'ogTitle' => 'Firecrawl',
+          'url' => 'https://www.firecrawl.dev/'
+        }
+      }
+    end
+
+    it 'creates a new document when one does not exist' do
+      expect do
+        described_class.perform_now(assistant_id: assistant.id, payload: payload)
+      end.to change(assistant.documents, :count).by(1)
+
+      document = assistant.documents.last
+      expect(document).to have_attributes(
+        content: payload[:markdown],
+        name: payload[:metadata]['title'],
+        external_link: 'https://www.firecrawl.dev',
+        status: 'available'
+      )
+    end
+
+    it 'updates existing document when one exists' do
+      existing_document = create(:captain_document,
+                                 assistant: assistant,
+                                 account: assistant.account,
+                                 external_link: 'https://www.firecrawl.dev',
+                                 content: 'old content',
+                                 name: 'old title',
+                                 status: :in_progress)
+
+      expect do
+        described_class.perform_now(assistant_id: assistant.id, payload: payload)
+      end.not_to change(assistant.documents, :count)
+
+      existing_document.reload
+      # Payload URL ends with '/', but we persist the canonical URL without it.
+      expect(existing_document).to have_attributes(
+        external_link: 'https://www.firecrawl.dev',
+        content: payload[:markdown],
+        name: payload[:metadata]['title'],
+        status: 'available'
+      )
+    end
+
+    context 'when an error occurs' do
+      it 'raises an error with a descriptive message' do
+        allow(Captain::Assistant).to receive(:find).and_raise(ActiveRecord::RecordNotFound)
+
+        expect do
+          described_class.perform_now(assistant_id: -1, payload: payload)
+        end.to raise_error(/Failed to parse FireCrawl data/)
+      end
+    end
+  end
+end

spec/enterprise/jobs/captain/tools/simple_page_crawl_parser_job_spec.rb

@@ -0,0 +1,97 @@
+require 'rails_helper'
+
+RSpec.describe Captain::Tools::SimplePageCrawlParserJob, type: :job do
+  describe '#perform' do
+    let(:assistant) { create(:captain_assistant) }
+    let(:page_link) { 'https://example.com/page/' }
+    let(:page_title) { 'Example Page Title' }
+    let(:content) { 'Some page content here' }
+    let(:crawler) { instance_double(Captain::Tools::SimplePageCrawlService) }
+
+    before do
+      allow(Captain::Tools::SimplePageCrawlService).to receive(:new)
+        .with(page_link)
+        .and_return(crawler)
+
+      allow(crawler).to receive(:page_title).and_return(page_title)
+      allow(crawler).to receive(:body_text_content).and_return(content)
+    end
+
+    context 'when the page is successfully crawled' do
+      it 'creates a new document if one does not exist' do
+        expect do
+          described_class.perform_now(assistant_id: assistant.id, page_link: page_link)
+        end.to change(assistant.documents, :count).by(1)
+
+        document = assistant.documents.last
+        expect(document.external_link).to eq('https://example.com/page')
+        expect(document.name).to eq(page_title)
+        expect(document.content).to eq(content)
+        expect(document.status).to eq('available')
+      end
+
+      it 'updates existing document if one exists' do
+        existing_document = create(:captain_document,
+                                   assistant: assistant,
+                                   external_link: 'https://example.com/page',
+                                   name: 'Old Title',
+                                   content: 'Old content')
+
+        expect do
+          described_class.perform_now(assistant_id: assistant.id, page_link: page_link)
+        end.not_to change(assistant.documents, :count)
+
+        existing_document.reload
+        expect(existing_document.name).to eq(page_title)
+        expect(existing_document.content).to eq(content)
+        expect(existing_document.status).to eq('available')
+      end
+
+      context 'when title or content exceed maximum length' do
+        let(:long_title) { 'x' * 300 }
+        let(:long_content) { 'x' * 20_000 }
+
+        before do
+          allow(crawler).to receive(:page_title).and_return(long_title)
+          allow(crawler).to receive(:body_text_content).and_return(long_content)
+        end
+
+        it 'truncates the title and content' do
+          described_class.perform_now(assistant_id: assistant.id, page_link: page_link)
+
+          document = assistant.documents.last
+          expect(document.name.length).to eq(255)
+          expect(document.content.length).to eq(15_000)
+        end
+      end
+    end
+
+    context 'when the crawler fails' do
+      before do
+        allow(crawler).to receive(:page_title).and_raise(StandardError.new('Failed to fetch'))
+      end
+
+      it 'raises an error with the page link' do
+        expect do
+          described_class.perform_now(assistant_id: assistant.id, page_link: page_link)
+        end.to raise_error("Failed to parse data: #{page_link} Failed to fetch")
+      end
+    end
+
+    context 'when title and content are nil' do
+      before do
+        allow(crawler).to receive(:page_title).and_return(nil)
+        allow(crawler).to receive(:body_text_content).and_return(nil)
+      end
+
+      it 'creates document with empty strings and updates the status to available' do
+        described_class.perform_now(assistant_id: assistant.id, page_link: page_link)
+
+        document = assistant.documents.last
+        expect(document.name).to eq('')
+        expect(document.content).to eq('')
+        expect(document.status).to eq('available')
+      end
+    end
+  end
+end