feat: Add support for more tool, standardize copilot chat service (#11560)

spec/enterprise/models/copilot_thread_spec.rb

@@ -47,9 +47,9 @@ RSpec.describe CopilotThread, type: :model do
 
         expect(history.length).to eq(2)
         expect(history[0][:role]).to eq('user')
-        expect(history[0][:content]).to eq({ 'content' => 'User message' })
+        expect(history[0][:content]).to eq('User message')
         expect(history[1][:role]).to eq('assistant')
-        expect(history[1][:content]).to eq({ 'content' => 'Assistant message' })
+        expect(history[1][:content]).to eq('Assistant message')
       end
     end
 

spec/enterprise/services/captain/copilot/chat_service_spec.rb

@@ -2,87 +2,245 @@ require 'rails_helper'
 
 RSpec.describe Captain::Copilot::ChatService do
   let(:account) { create(:account, custom_attributes: { plan_name: 'startups' }) }
-  let(:captain_inbox_association) { create(:captain_inbox, captain_assistant: assistant, inbox: inbox) }
-  let(:mock_captain_agent) { instance_double(Captain::Agent) }
-  let(:mock_captain_tool) { instance_double(Captain::Tool) }
-  let(:mock_openai_client) { instance_double(OpenAI::Client) }
+  let(:user) { create(:user, account: account) }
   let(:inbox) { create(:inbox, account: account) }
   let(:assistant) { create(:captain_assistant, account: account) }
+  let(:contact) { create(:contact, account: account) }
+  let(:conversation) { create(:conversation, account: account, inbox: inbox, contact: contact) }
+  let(:mock_openai_client) { instance_double(OpenAI::Client) }
+  let(:copilot_thread) { create(:captain_copilot_thread, account: account, user: user) }
+  let!(:copilot_message) do
+    create(
+      :captain_copilot_message, account: account, copilot_thread: copilot_thread
+    )
+  end
+  let(:previous_history) { [{ role: copilot_message.message_type, content: copilot_message.message['content'] }] }
+
+  let(:config) do
+    { user_id: user.id, thread_id: copilot_thread.id, conversation_id: conversation.display_id }
+  end
 
   before do
     create(:installation_config, name: 'CAPTAIN_OPEN_AI_API_KEY', value: 'test-key')
+    allow(OpenAI::Client).to receive(:new).and_return(mock_openai_client)
+    allow(mock_openai_client).to receive(:chat).and_return({
+      choices: [{ message: { content: '{ "content": "Hey" }' } }]
+    }.with_indifferent_access)
   end
 
   describe '#initialize' do
-    it 'sets default language to english when not specified' do
-      service = described_class.new(assistant, { previous_messages: [], conversation_history: '' })
-      expect(service.instance_variable_get(:@language)).to eq('english')
+    it 'sets up the service with correct instance variables' do
+      service = described_class.new(assistant, config)
+
+      expect(service.assistant).to eq(assistant)
+      expect(service.account).to eq(account)
+      expect(service.user).to eq(user)
+      expect(service.copilot_thread).to eq(copilot_thread)
+      expect(service.previous_history).to eq(previous_history)
     end
 
-    it 'uses the specified language when provided' do
-      service = described_class.new(assistant, {
-                                      previous_messages: [],
-                                      conversation_history: '',
-                                      language: 'spanish'
-                                    })
-      expect(service.instance_variable_get(:@language)).to eq('spanish')
+    it 'builds messages with system message and account context' do
+      service = described_class.new(assistant, config)
+      messages = service.messages
+
+      expect(messages.first[:role]).to eq('system')
+      expect(messages.second[:role]).to eq('system')
+      expect(messages.second[:content]).to include(account.id.to_s)
     end
   end
 
   describe '#generate_response' do
-    before do
-      allow(OpenAI::Client).to receive(:new).and_return(mock_openai_client)
-      allow(mock_openai_client).to receive(:chat).and_return({ choices: [{ message: { content: '{ "result": "Hey" }' } }] }.with_indifferent_access)
+    let(:service) { described_class.new(assistant, config) }
 
-      allow(Captain::Agent).to receive(:new).and_return(mock_captain_agent)
-      allow(mock_captain_agent).to receive(:execute).and_return(true)
-      allow(mock_captain_agent).to receive(:register_tool).and_return(true)
+    it 'adds user input to messages when present' do
+      expect do
+        service.generate_response('Hello')
+      end.to(change { service.messages.count }.by(1))
 
-      allow(Captain::Tool).to receive(:new).and_return(mock_captain_tool)
-      allow(mock_captain_tool).to receive(:register_method).and_return(true)
-
-      allow(account).to receive(:increment_response_usage).and_return(true)
+      last_message = service.messages.last
+      expect(last_message[:role]).to eq('user')
+      expect(last_message[:content]).to eq('Hello')
     end
 
-    it 'increments usage' do
-      described_class.new(assistant, { previous_messages: ['Hello'], conversation_history: 'Hi' }).generate_response('Hey')
-      expect(account).to have_received(:increment_response_usage).once
+    it 'does not add user input to messages when blank' do
+      expect do
+        service.generate_response('')
+      end.not_to(change { service.messages.count })
     end
 
-    it 'includes language in system message' do
-      service = described_class.new(assistant, {
-                                      previous_messages: [],
-                                      conversation_history: '',
-                                      language: 'spanish'
-                                    })
+    it 'returns the response from request_chat_completion' do
+      expect(service.generate_response('Hello')).to eq({ 'content' => 'Hey' })
+    end
 
-      allow(Captain::Llm::SystemPromptsService).to receive(:copilot_response_generator)
-        .with(assistant.config['product_name'], 'spanish')
-        .and_return('Spanish system prompt')
+    context 'when response contains tool calls' do
+      before do
+        allow(mock_openai_client).to receive(:chat).and_return(
+          {
+            choices: [{ message: { 'tool_calls' => tool_calls } }]
+          }.with_indifferent_access,
+          {
+            choices: [{ message: { content: '{ "content": "Tool response processed" }' } }]
+          }.with_indifferent_access
+        )
+      end
 
-      system_message = service.send(:system_message)
-      expect(system_message[:content]).to eq('Spanish system prompt')
+      context 'when tool call is valid' do
+        let(:tool_calls) do
+          [{
+            'id' => 'call_123',
+            'function' => {
+              'name' => 'get_conversation',
+              'arguments' => "{ \"conversation_id\": #{conversation.display_id} }"
+            }
+          }]
+        end
+
+        it 'processes tool calls and appends them to messages' do
+          result = service.generate_response("Find conversation #{conversation.id}")
+
+          expect(result).to eq({ 'content' => 'Tool response processed' })
+          expect(service.messages).to include(
+            { role: 'assistant', tool_calls: tool_calls }
+          )
+          expect(service.messages).to include(
+            {
+              role: 'tool', tool_call_id: 'call_123', content: conversation.to_llm_text
+            }
+          )
+
+          expect(result).to eq({ 'content' => 'Tool response processed' })
+        end
+      end
+
+      context 'when tool call is invalid' do
+        let(:tool_calls) do
+          [{
+            'id' => 'call_123',
+            'function' => {
+              'name' => 'get_settings',
+              'arguments' => '{}'
+            }
+          }]
+        end
+
+        it 'handles invalid tool calls' do
+          result = service.generate_response('Find settings')
+
+          expect(result).to eq({ 'content' => 'Tool response processed' })
+          expect(service.messages).to include(
+            {
+              role: 'assistant', tool_calls: tool_calls
+            }
+          )
+          expect(service.messages).to include(
+            {
+              role: 'tool',
+              tool_call_id: 'call_123',
+              content: 'Tool not available'
+            }
+          )
+        end
+      end
     end
   end
 
-  describe '#execute' do
-    before do
-      allow(OpenAI::Client).to receive(:new).and_return(mock_openai_client)
-      allow(mock_openai_client).to receive(:chat).and_return({ choices: [{ message: { content: '{ "result": "Hey" }' } }] }.with_indifferent_access)
-
-      allow(Captain::Agent).to receive(:new).and_return(mock_captain_agent)
-      allow(mock_captain_agent).to receive(:execute).and_return(true)
-      allow(mock_captain_agent).to receive(:register_tool).and_return(true)
-
-      allow(Captain::Tool).to receive(:new).and_return(mock_captain_tool)
-      allow(mock_captain_tool).to receive(:register_method).and_return(true)
-
-      allow(account).to receive(:increment_response_usage).and_return(true)
+  describe '#setup_user' do
+    it 'sets user when user_id is present in config' do
+      service = described_class.new(assistant, { user_id: user.id })
+      expect(service.user).to eq(user)
     end
 
-    it 'increments usage' do
-      described_class.new(assistant, { previous_messages: ['Hello'], conversation_history: 'Hi' }).generate_response('Hey')
-      expect(account).to have_received(:increment_response_usage).once
+    it 'does not set user when user_id is not present in config' do
+      service = described_class.new(assistant, {})
+      expect(service.user).to be_nil
+    end
+  end
+
+  describe '#setup_message_history' do
+    context 'when thread_id is present' do
+      it 'finds the copilot thread and sets previous history from it' do
+        service = described_class.new(assistant, { thread_id: copilot_thread.id })
+
+        expect(service.copilot_thread).to eq(copilot_thread)
+        expect(service.previous_history).to eq previous_history
+      end
+    end
+
+    context 'when thread_id is not present' do
+      it 'uses previous_history from config if present' do
+        custom_history = [{ role: 'user', content: 'Custom message' }]
+        service = described_class.new(assistant, { previous_history: custom_history })
+
+        expect(service.copilot_thread).to be_nil
+        expect(service.previous_history).to eq(custom_history)
+      end
+
+      it 'uses empty array if previous_history is not present in config' do
+        service = described_class.new(assistant, {})
+
+        expect(service.copilot_thread).to be_nil
+        expect(service.previous_history).to eq([])
+      end
+    end
+  end
+
+  describe '#build_messages' do
+    it 'includes system message and account context' do
+      service = described_class.new(assistant, {})
+      messages = service.messages
+
+      expect(messages.first[:role]).to eq('system')
+      expect(messages.second[:role]).to eq('system')
+      expect(messages.second[:content]).to include(account.id.to_s)
+    end
+
+    it 'includes previous history when present' do
+      custom_history = [{ role: 'user', content: 'Custom message' }]
+      service = described_class.new(assistant, { previous_history: custom_history })
+      messages = service.messages
+
+      expect(messages.count).to be >= 3
+      expect(messages.any? { |m| m[:content] == 'Custom message' }).to be true
+    end
+
+    it 'includes current viewing history when conversation_id is present' do
+      service = described_class.new(assistant, { conversation_id: conversation.display_id })
+      messages = service.messages
+
+      viewing_history = messages.find { |m| m[:content].include?('You are currently viewing the conversation') }
+      expect(viewing_history).not_to be_nil
+      expect(viewing_history[:content]).to include(conversation.display_id.to_s)
+      expect(viewing_history[:content]).to include(contact.id.to_s)
+    end
+  end
+
+  describe '#persist_message' do
+    context 'when copilot_thread is present' do
+      it 'creates a copilot message' do
+        allow(mock_openai_client).to receive(:chat).and_return({
+          choices: [{ message: { content: '{ "content": "Hey" }' } }]
+        }.with_indifferent_access)
+
+        expect do
+          described_class.new(assistant, { thread_id: copilot_thread.id }).generate_response('Hello')
+        end.to change(CopilotMessage, :count).by(1)
+
+        last_message = CopilotMessage.last
+        expect(last_message.message_type).to eq('assistant')
+        expect(last_message.message['content']).to eq('Hey')
+      end
+    end
+
+    context 'when copilot_thread is not present' do
+      it 'does not create a copilot message' do
+        allow(mock_openai_client).to receive(:chat).and_return({
+          choices: [{ message: { content: '{ "content": "Hey" }' } }]
+        }.with_indifferent_access)
+
+        expect do
+          described_class.new(assistant, {}).generate_response('Hello')
+        end.not_to(change(CopilotMessage, :count))
+      end
     end
   end
 end

spec/listeners/action_cable_listener_spec.rb

@@ -203,24 +203,4 @@ describe ActionCableListener do
       listener.conversation_updated(event)
     end
   end
-
-  describe '#copilot_message_created' do
-    let(:event_name) { :copilot_message_created }
-    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(:copilot_message) { create(:captain_copilot_message, copilot_thread: copilot_thread) }
-    let(:event) { Events::Base.new(event_name, Time.zone.now, copilot_message: copilot_message) }
-
-    it 'broadcasts message to the user' do
-      expect(ActionCableBroadcastJob).to receive(:perform_later).with(
-        [user.pubsub_token],
-        'copilot.message.created',
-        copilot_message.push_event_data
-      )
-
-      listener.copilot_message_created(event)
-    end
-  end
 end