diff --git a/app/javascript/dashboard/routes/dashboard/captain/assistants/overview/Index.vue b/app/javascript/dashboard/routes/dashboard/captain/assistants/overview/Index.vue
index 29411e56d..ba31bc05d 100644
--- a/app/javascript/dashboard/routes/dashboard/captain/assistants/overview/Index.vue
+++ b/app/javascript/dashboard/routes/dashboard/captain/assistants/overview/Index.vue
@@ -1,5 +1,5 @@
diff --git a/app/javascript/dashboard/routes/dashboard/settings/inbox/Settings.vue b/app/javascript/dashboard/routes/dashboard/settings/inbox/Settings.vue
index 222d238a8..5e7f320f3 100644
--- a/app/javascript/dashboard/routes/dashboard/settings/inbox/Settings.vue
+++ b/app/javascript/dashboard/routes/dashboard/settings/inbox/Settings.vue
@@ -390,6 +390,11 @@ export default {
return (
this.isAWhatsAppCloudChannel &&
this.isEmbeddedSignupWhatsApp &&
+ (!this.isOnChatwootCloud ||
+ this.isFeatureEnabledonAccount(
+ this.accountId,
+ FEATURE_FLAGS.WHATSAPP_EMBEDDED_SIGNUP_FLOW
+ )) &&
this.inbox.reauthorization_required
);
},
diff --git a/app/javascript/dashboard/routes/dashboard/settings/inbox/channels/Whatsapp.vue b/app/javascript/dashboard/routes/dashboard/settings/inbox/channels/Whatsapp.vue
index b4e0c58af..6a4a361b0 100644
--- a/app/javascript/dashboard/routes/dashboard/settings/inbox/channels/Whatsapp.vue
+++ b/app/javascript/dashboard/routes/dashboard/settings/inbox/channels/Whatsapp.vue
@@ -42,9 +42,7 @@ const shouldShowWhatsappEmbeddedSignup = computed(() => {
selectedProvider.value === PROVIDER_TYPES.WHATSAPP &&
hasWhatsappAppId.value &&
(!isOnChatwootCloud.value ||
- isCloudFeatureEnabled(
- FEATURE_FLAGS.WHATSAPP_EMBEDDED_SIGNUP_INBOX_CREATION
- ))
+ isCloudFeatureEnabled(FEATURE_FLAGS.WHATSAPP_EMBEDDED_SIGNUP_FLOW))
);
});
diff --git a/app/javascript/dashboard/routes/dashboard/settings/inbox/components/SenderNameExamplePreview.vue b/app/javascript/dashboard/routes/dashboard/settings/inbox/components/SenderNameExamplePreview.vue
index abd2552bf..b08d282aa 100644
--- a/app/javascript/dashboard/routes/dashboard/settings/inbox/components/SenderNameExamplePreview.vue
+++ b/app/javascript/dashboard/routes/dashboard/settings/inbox/components/SenderNameExamplePreview.vue
@@ -3,6 +3,7 @@ import { computed } from 'vue';
import { useI18n } from 'vue-i18n';
import Avatar from 'next/avatar/Avatar.vue';
import RadioCard from 'dashboard/components-next/radioCard/RadioCard.vue';
+import { useBranding } from 'shared/composables/useBranding';
const props = defineProps({
senderNameType: {
@@ -22,6 +23,7 @@ const props = defineProps({
const emit = defineEmits(['update']);
const { t } = useI18n();
+const { replaceInstallationName } = useBranding();
const senderNameKeyOptions = computed(() => [
{
@@ -30,7 +32,7 @@ const senderNameKeyOptions = computed(() => [
content: t('INBOX_MGMT.EDIT.SENDER_NAME_SECTION.FRIENDLY.SUBTITLE'),
preview: {
senderName: 'Smith',
- businessName: 'Chatwoot',
+ businessName: replaceInstallationName('Chatwoot'),
email: '',
},
},
@@ -40,7 +42,7 @@ const senderNameKeyOptions = computed(() => [
content: t('INBOX_MGMT.EDIT.SENDER_NAME_SECTION.PROFESSIONAL.SUBTITLE'),
preview: {
senderName: '',
- businessName: 'Chatwoot',
+ businessName: replaceInstallationName('Chatwoot'),
email: '',
},
},
@@ -51,7 +53,7 @@ const isKeyOptionFriendly = key => key === 'friendly';
const userName = keyOption =>
isKeyOptionFriendly(keyOption.key)
? keyOption.preview.senderName
- : keyOption.preview.businessName;
+ : props.businessName || keyOption.preview.businessName;
const toggleSenderNameType = key => {
emit('update', key);
diff --git a/app/javascript/dashboard/routes/dashboard/settings/inbox/settingsPage/ConfigurationPage.vue b/app/javascript/dashboard/routes/dashboard/settings/inbox/settingsPage/ConfigurationPage.vue
index 61038cec1..1e9e2f704 100644
--- a/app/javascript/dashboard/routes/dashboard/settings/inbox/settingsPage/ConfigurationPage.vue
+++ b/app/javascript/dashboard/routes/dashboard/settings/inbox/settingsPage/ConfigurationPage.vue
@@ -56,6 +56,7 @@ export default {
...mapGetters({
accountId: 'getCurrentAccountId',
isFeatureEnabledonAccount: 'accounts/isFeatureEnabledonAccount',
+ isOnChatwootCloud: 'globalConfig/isOnChatwootCloud',
}),
isEmbeddedSignupWhatsApp() {
return this.inbox.provider_config?.source === 'embedded_signup';
@@ -65,7 +66,9 @@ export default {
this.isEmbeddedSignupWhatsApp &&
this.isFeatureEnabledonAccount(
this.accountId,
- FEATURE_FLAGS.WHATSAPP_RECONFIGURE
+ this.isOnChatwootCloud
+ ? FEATURE_FLAGS.WHATSAPP_EMBEDDED_SIGNUP_FLOW
+ : FEATURE_FLAGS.WHATSAPP_RECONFIGURE
)
);
},
diff --git a/app/javascript/dashboard/store/captain/agentSessions.js b/app/javascript/dashboard/store/captain/agentSessions.js
new file mode 100644
index 000000000..e72d2e58c
--- /dev/null
+++ b/app/javascript/dashboard/store/captain/agentSessions.js
@@ -0,0 +1,62 @@
+import CaptainAgentSessionsAPI from 'dashboard/api/captain/agentSessions';
+import camelcaseKeys from 'camelcase-keys';
+
+const SET_SESSION = 'SET_SESSION';
+const SET_FETCHING = 'SET_FETCHING';
+
+// Session capture runs right after the message is broadcast (and well after,
+// for handoff notes created mid-run), so a 404 on a fresh message may just
+// mean the session isn't written yet. Skip caching those so a later
+// hover/click retries; older misses are permanent (V1 messages, failed runs).
+const RECENT_MESSAGE_WINDOW_SECONDS = 60;
+
+// Caches Captain agent-session metadata per message id. A missing session
+// (404) is cached as null so the UI shows an empty state without refetching.
+export default {
+ namespaced: true,
+ state: {
+ sessions: {},
+ fetchingIds: [],
+ },
+ getters: {
+ getSessionByMessageId: state => messageId => state.sessions[messageId],
+ isFetching: state => messageId => state.fetchingIds.includes(messageId),
+ hasFetched: state => messageId => messageId in state.sessions,
+ },
+ actions: {
+ fetch: async ({ state, commit }, { messageId, createdAt }) => {
+ if (messageId in state.sessions) return;
+ if (state.fetchingIds.includes(messageId)) return;
+
+ commit(SET_FETCHING, { messageId, isFetching: true });
+ try {
+ const { data } = await CaptainAgentSessionsAPI.show(messageId);
+ commit(SET_SESSION, {
+ messageId,
+ session: camelcaseKeys(data, { deep: true }),
+ });
+ } catch (error) {
+ const isRecentMessage =
+ createdAt &&
+ Date.now() / 1000 - createdAt < RECENT_MESSAGE_WINDOW_SECONDS;
+ // Only a 404 means "no session exists"; transient failures (5xx,
+ // network errors) stay uncached so a later hover retries.
+ if (error.response?.status === 404 && !isRecentMessage) {
+ commit(SET_SESSION, { messageId, session: null });
+ }
+ } finally {
+ commit(SET_FETCHING, { messageId, isFetching: false });
+ }
+ },
+ },
+ mutations: {
+ [SET_SESSION](state, { messageId, session }) {
+ state.sessions = { ...state.sessions, [messageId]: session };
+ },
+ [SET_FETCHING](state, { messageId, isFetching }) {
+ state.fetchingIds = isFetching
+ ? [...state.fetchingIds, messageId]
+ : state.fetchingIds.filter(id => id !== messageId);
+ },
+ },
+};
diff --git a/app/javascript/dashboard/store/index.js b/app/javascript/dashboard/store/index.js
index 23685bfad..d0c8e5002 100755
--- a/app/javascript/dashboard/store/index.js
+++ b/app/javascript/dashboard/store/index.js
@@ -50,6 +50,7 @@ import teamMembers from './modules/teamMembers';
import teams from './modules/teams';
import userNotificationSettings from './modules/userNotificationSettings';
import webhooks from './modules/webhooks';
+import captainAgentSessions from './captain/agentSessions';
import captainAssistants from './captain/assistant';
import captainDocuments from './captain/document';
import captainResponses from './captain/response';
@@ -115,6 +116,7 @@ export default createStore({
teams,
userNotificationSettings,
webhooks,
+ captainAgentSessions,
captainAssistants,
captainDocuments,
captainResponses,
diff --git a/app/javascript/dashboard/store/modules/inboxes.js b/app/javascript/dashboard/store/modules/inboxes.js
index ce24ef653..64a29c215 100644
--- a/app/javascript/dashboard/store/modules/inboxes.js
+++ b/app/javascript/dashboard/store/modules/inboxes.js
@@ -7,6 +7,7 @@ import FBChannel from '../../api/channel/fbChannel';
import TwilioChannel from '../../api/channel/twilioChannel';
import WhatsappChannel from '../../api/channel/whatsappChannel';
import { throwErrorMessage } from '../utils/api';
+import { isSendableTemplate } from '@chatwoot/utils';
import AnalyticsHelper from '../../helper/AnalyticsHelper';
import camelcaseKeys from 'camelcase-keys';
import { ACCOUNT_EVENTS } from '../../helper/AnalyticsHelper/events';
@@ -67,45 +68,8 @@ export const getters = {
return [];
}
- return templates.filter(template => {
- // Ensure template has required properties
- if (!template || !template.status || !template.components) {
- return false;
- }
-
- // Only show approved templates
- if (template.status.toLowerCase() !== 'approved') {
- return false;
- }
-
- // Filter out authentication templates
- if (template.category === 'AUTHENTICATION') {
- return false;
- }
-
- // Filter out CSAT templates (customer_satisfaction_survey and its versions)
- if (
- template.name &&
- template.name.startsWith('customer_satisfaction_survey')
- ) {
- return false;
- }
-
- // Filter out interactive templates (LIST, PRODUCT, CATALOG), location templates, and call permission templates
- const hasUnsupportedComponents = template.components.some(
- component =>
- ['LIST', 'PRODUCT', 'CATALOG', 'CALL_PERMISSION_REQUEST'].includes(
- component.type
- ) ||
- (component.type === 'HEADER' && component.format === 'LOCATION')
- );
-
- if (hasUnsupportedComponents) {
- return false;
- }
-
- return true;
- });
+ // Sendable-template filtering is shared with the mobile app via @chatwoot/utils.
+ return templates.filter(isSendableTemplate);
},
getNewConversationInboxes($state) {
return $state.records.filter(inbox => {
diff --git a/app/javascript/shared/composables/specs/useBranding.spec.js b/app/javascript/shared/composables/specs/useBranding.spec.js
index 6f3f06b67..4477ac052 100644
--- a/app/javascript/shared/composables/specs/useBranding.spec.js
+++ b/app/javascript/shared/composables/specs/useBranding.spec.js
@@ -73,13 +73,13 @@ describe('useBranding', () => {
expect(result).toBe('Welcome to our platform');
});
- it('should be case-sensitive for "Chatwoot"', () => {
+ it('should replace "Chatwoot" regardless of casing', () => {
const { replaceInstallationName } = useBranding();
const result = replaceInstallationName(
- 'Welcome to chatwoot and CHATWOOT'
+ 'Welcome to chatwoot, Chatwoot and CHATWOOT'
);
- expect(result).toBe('Welcome to chatwoot and CHATWOOT');
+ expect(result).toBe('Welcome to MyCompany, MyCompany and MyCompany');
});
it('should handle special characters in installation name', () => {
diff --git a/app/javascript/shared/composables/useBranding.js b/app/javascript/shared/composables/useBranding.js
index fccdcd32b..d9be3e696 100644
--- a/app/javascript/shared/composables/useBranding.js
+++ b/app/javascript/shared/composables/useBranding.js
@@ -7,7 +7,8 @@ import { useMapGetter } from 'dashboard/composables/store.js';
export function useBranding() {
const globalConfig = useMapGetter('globalConfig/get');
/**
- * Replaces "Chatwoot" in text with the installation name from global config
+ * Replaces "Chatwoot" (any casing) in text with the installation name from
+ * global config
* @param {string} text - The text to process
* @returns {string} - Text with "Chatwoot" replaced by installation name
*/
@@ -17,7 +18,7 @@ export function useBranding() {
const installationName = globalConfig.value?.installationName;
if (!installationName) return text;
- return text.replace(/Chatwoot/g, installationName);
+ return text.replace(/chatwoot/gi, installationName);
};
return {
diff --git a/app/services/whatsapp/incoming_message_base_service.rb b/app/services/whatsapp/incoming_message_base_service.rb
index 00936ff15..09632c5b1 100644
--- a/app/services/whatsapp/incoming_message_base_service.rb
+++ b/app/services/whatsapp/incoming_message_base_service.rb
@@ -113,12 +113,14 @@ class Whatsapp::IncomingMessageBaseService
end
def set_conversation
+ # Scope reuse to the contact across all its contact_inboxes in this inbox: WhatsApp coexistence
+ # gives one contact multiple source_ids (phone + BSUID), so reopen must not be limited to a single contact_inbox.
+ conversations = @contact.conversations.where(inbox_id: @inbox.id)
# if lock to single conversation is disabled, we will create a new conversation if previous conversation is resolved
@conversation = if @inbox.lock_to_single_conversation
- @contact_inbox.conversations.last
+ conversations.last
else
- @contact_inbox.conversations
- .where.not(status: :resolved).last
+ conversations.where.not(status: :resolved).last
end
return if @conversation
diff --git a/config/features.yml b/config/features.yml
index 590f28814..950d6e7c5 100644
--- a/config/features.yml
+++ b/config/features.yml
@@ -265,6 +265,6 @@
enabled: false
column: feature_flags_ext_1
- name: whatsapp_embedded_signup_inbox_creation
- display_name: WhatsApp Embedded Signup Inbox Creation
+ display_name: WhatsApp Embedded Signup Flow
enabled: false
column: feature_flags_ext_1
diff --git a/config/initializers/rack_attack.rb b/config/initializers/rack_attack.rb
index e08a6a6e1..caf49c047 100644
--- a/config/initializers/rack_attack.rb
+++ b/config/initializers/rack_attack.rb
@@ -31,10 +31,11 @@ class Rack::Attack
(default_allowed_ips + env_allowed_ips).include?(remote_ip)
end
- # Rails would allow requests to paths with extensions, so lets compare against the path with extension stripped
- # example /auth & /auth.json would both work
+ # Rails allows paths with extensions and trailing slashes, so compare against a normalized path.
+ # For example, /auth, /auth.json, and /auth/ should all use the same throttle.
def path_without_extensions
- path[/^[^.]+/]
+ normalized_path = path[/^[^.]+/]
+ normalized_path == '/' ? normalized_path : normalized_path.sub(%r{/+\z}, '')
end
end
@@ -188,6 +189,11 @@ class Rack::Attack
throttle('widget?website_token={website_token}&cw_conversation={x-auth-token}', limit: 5, period: 1.hour) do |req|
req.ip if req.path_without_extensions == '/widget' && ActionDispatch::Request.new(req.env).params['cw_conversation'].blank?
end
+
+ ## Prevent Transcript Bombing on Widget API ###
+ throttle('api/v1/widget/conversations/transcript', limit: 5, period: 1.hour) do |req|
+ req.ip if req.path_without_extensions == '/api/v1/widget/conversations/transcript' && req.post?
+ end
end
##-----------------------------------------------##
@@ -212,6 +218,24 @@ class Rack::Attack
match_data[:account_id] if match_data.present?
end
+ ## Prevent abuse of agent create APIs (per account, covers bulk_create)
+ throttle('/api/v1/accounts/:account_id/agents POST',
+ limit: ENV.fetch('RATE_LIMIT_AGENT_CREATE', '100').to_i, period: 1.day) do |req|
+ next unless req.post?
+
+ match_data = %r{\A/api/v1/accounts/(?\d+)/agents(?:/bulk_create)?/?\z}.match(req.path_without_extensions)
+ match_data[:account_id] if match_data.present?
+ end
+
+ ## Prevent abuse of agent delete API (per account)
+ throttle('/api/v1/accounts/:account_id/agents/:id DELETE',
+ limit: ENV.fetch('RATE_LIMIT_AGENT_DELETE', '50').to_i, period: 1.day) do |req|
+ next unless req.delete?
+
+ match_data = %r{\A/api/v1/accounts/(?\d+)/agents/(?\d+)/?\z}.match(req.path_without_extensions)
+ match_data[:account_id] if match_data.present?
+ end
+
## Prevent Abuse of attachment upload APIs ##
throttle('/api/v1/accounts/:account_id/upload', limit: 60, period: 1.hour) do |req|
match_data = %r{/api/v1/accounts/(?\d+)/upload}.match(req.path)
diff --git a/config/routes.rb b/config/routes.rb
index dfdc23727..0bf6b40c8 100644
--- a/config/routes.rb
+++ b/config/routes.rb
@@ -76,6 +76,7 @@ Rails.application.routes.draw do
resources :inboxes, only: [:index, :create, :destroy], param: :inbox_id
resources :scenarios
end
+ resources :agent_sessions, only: [:show]
resources :assistant_responses
resources :message_reports, only: [:create]
resources :bulk_actions, only: [:create]
diff --git a/enterprise/app/controllers/api/v1/accounts/captain/agent_sessions_controller.rb b/enterprise/app/controllers/api/v1/accounts/captain/agent_sessions_controller.rb
new file mode 100644
index 000000000..f9163de04
--- /dev/null
+++ b/enterprise/app/controllers/api/v1/accounts/captain/agent_sessions_controller.rb
@@ -0,0 +1,25 @@
+class Api::V1::Accounts::Captain::AgentSessionsController < Api::V1::Accounts::BaseController
+ before_action :set_message
+ before_action :authorize_conversation
+
+ def show
+ @agent_session = Current.account.captain_agent_sessions.find_by(result_type: 'Message', result_id: @message.id)
+ return head :not_found if @agent_session.blank?
+
+ @citations = Current.account.captain_assistant_responses
+ .where(id: @agent_session.faq_ids)
+ .includes(:documentable)
+ @scenario_titles = Captain::Scenario.where(account_id: Current.account.id, id: @agent_session.scenario_ids)
+ .pluck(:id, :title).to_h
+ end
+
+ private
+
+ def set_message
+ @message = Current.account.messages.find(params[:id])
+ end
+
+ def authorize_conversation
+ authorize @message.conversation, :show?
+ end
+end
diff --git a/enterprise/app/controllers/api/v1/accounts/captain/assistant_responses_controller.rb b/enterprise/app/controllers/api/v1/accounts/captain/assistant_responses_controller.rb
index 151cf279c..80e05e912 100644
--- a/enterprise/app/controllers/api/v1/accounts/captain/assistant_responses_controller.rb
+++ b/enterprise/app/controllers/api/v1/accounts/captain/assistant_responses_controller.rb
@@ -1,5 +1,4 @@
class Api::V1::Accounts::Captain::AssistantResponsesController < Api::V1::Accounts::BaseController
- before_action :current_account
before_action -> { check_authorization(Captain::Assistant) }
before_action :set_current_page, only: [:index]
diff --git a/enterprise/app/controllers/api/v1/accounts/captain/assistants_controller.rb b/enterprise/app/controllers/api/v1/accounts/captain/assistants_controller.rb
index 4fbb93d20..1b7d77289 100644
--- a/enterprise/app/controllers/api/v1/accounts/captain/assistants_controller.rb
+++ b/enterprise/app/controllers/api/v1/accounts/captain/assistants_controller.rb
@@ -1,5 +1,4 @@
class Api::V1::Accounts::Captain::AssistantsController < Api::V1::Accounts::BaseController
- before_action :current_account
before_action -> { check_authorization(Captain::Assistant) }
before_action :set_assistant, only: [:show, :update, :destroy, :playground, :stats, :summary, :drilldown]
@@ -48,7 +47,8 @@ class Api::V1::Accounts::Captain::AssistantsController < Api::V1::Accounts::Base
end
def summary
- result = cached_or_generated_summary(Captain::AssistantStatsBuilder.new(@assistant, params[:range], params[:timezone_offset]))
+ window = Captain::AssistantStatsWindow.new(params[:range], params[:timezone_offset])
+ result = cached_or_generated_summary(window, summary_stats)
if result[:error]
render json: { error: result[:error] }, status: :unprocessable_content
@@ -69,8 +69,8 @@ class Api::V1::Accounts::Captain::AssistantsController < Api::V1::Accounts::Base
params.permit(:metric, :range, :timezone_offset, :page, :per_page)
end
- def cached_or_generated_summary(builder)
- cache_key = summary_cache_key(builder.range)
+ def cached_or_generated_summary(window, stats)
+ cache_key = summary_cache_key(window.range)
cached = Rails.cache.read(cache_key)
return cached if cached
@@ -78,14 +78,25 @@ class Api::V1::Accounts::Captain::AssistantsController < Api::V1::Accounts::Base
account: Current.account,
assistant: @assistant,
first_name: Current.user.name.to_s.split.first,
- stats: builder.metrics,
- period: builder.period
+ stats: stats,
+ period: window.period
).perform
# Don't cache transient LLM/config failures, otherwise every reload returns 422 for the next hour.
Rails.cache.write(cache_key, result, expires_in: 1.hour) unless result[:error]
result
end
+ def summary_stats
+ params.require(:stats).permit(
+ conversations_handled: %i[current],
+ hours_saved: %i[current],
+ auto_resolution_rate: %i[current trend],
+ handoff_rate: %i[current trend],
+ reopen_rate: %i[current trend],
+ knowledge: %i[coverage approved documents]
+ ).to_h.deep_symbolize_keys
+ end
+
def summary_cache_key(range)
"captain_overview_summary/#{@assistant.id}/#{Current.user.id}/#{range}/#{Date.current}"
end
diff --git a/enterprise/app/controllers/api/v1/accounts/captain/bulk_actions_controller.rb b/enterprise/app/controllers/api/v1/accounts/captain/bulk_actions_controller.rb
index 7e2817f69..2bd7c8eed 100644
--- a/enterprise/app/controllers/api/v1/accounts/captain/bulk_actions_controller.rb
+++ b/enterprise/app/controllers/api/v1/accounts/captain/bulk_actions_controller.rb
@@ -1,5 +1,4 @@
class Api::V1::Accounts::Captain::BulkActionsController < Api::V1::Accounts::BaseController
- before_action :current_account
before_action -> { check_authorization(Captain::Assistant) }
before_action :validate_params
before_action :type_matches?
diff --git a/enterprise/app/controllers/api/v1/accounts/captain/custom_tools_controller.rb b/enterprise/app/controllers/api/v1/accounts/captain/custom_tools_controller.rb
index 874197870..f0222434c 100644
--- a/enterprise/app/controllers/api/v1/accounts/captain/custom_tools_controller.rb
+++ b/enterprise/app/controllers/api/v1/accounts/captain/custom_tools_controller.rb
@@ -1,5 +1,4 @@
class Api::V1::Accounts::Captain::CustomToolsController < Api::V1::Accounts::BaseController
- before_action :current_account
before_action :ensure_custom_tools_enabled
before_action -> { check_authorization(Captain::CustomTool) }
before_action :set_custom_tool, only: [:show, :update, :destroy]
diff --git a/enterprise/app/controllers/api/v1/accounts/captain/documents_controller.rb b/enterprise/app/controllers/api/v1/accounts/captain/documents_controller.rb
index d88cc6b48..cb6fb782d 100644
--- a/enterprise/app/controllers/api/v1/accounts/captain/documents_controller.rb
+++ b/enterprise/app/controllers/api/v1/accounts/captain/documents_controller.rb
@@ -1,5 +1,4 @@
class Api::V1::Accounts::Captain::DocumentsController < Api::V1::Accounts::BaseController
- before_action :current_account
before_action -> { check_authorization(Captain::Assistant) }
before_action :set_current_page, only: [:index]
diff --git a/enterprise/app/controllers/api/v1/accounts/captain/inboxes_controller.rb b/enterprise/app/controllers/api/v1/accounts/captain/inboxes_controller.rb
index f4ec303b6..88b8f2fb3 100644
--- a/enterprise/app/controllers/api/v1/accounts/captain/inboxes_controller.rb
+++ b/enterprise/app/controllers/api/v1/accounts/captain/inboxes_controller.rb
@@ -1,5 +1,4 @@
class Api::V1::Accounts::Captain::InboxesController < Api::V1::Accounts::BaseController
- before_action :current_account
before_action -> { check_authorization(Captain::Assistant) }
before_action :set_assistant
diff --git a/enterprise/app/controllers/api/v1/accounts/captain/scenarios_controller.rb b/enterprise/app/controllers/api/v1/accounts/captain/scenarios_controller.rb
index 376cee0b3..fa7157dae 100644
--- a/enterprise/app/controllers/api/v1/accounts/captain/scenarios_controller.rb
+++ b/enterprise/app/controllers/api/v1/accounts/captain/scenarios_controller.rb
@@ -1,5 +1,4 @@
class Api::V1::Accounts::Captain::ScenariosController < Api::V1::Accounts::BaseController
- before_action :current_account
before_action -> { check_authorization(Captain::Scenario) }
before_action :set_assistant
before_action :set_scenario, only: [:show, :update, :destroy]
diff --git a/enterprise/app/controllers/api/v1/accounts/whatsapp_calls_controller.rb b/enterprise/app/controllers/api/v1/accounts/whatsapp_calls_controller.rb
index a0627ce49..2f86e0de8 100644
--- a/enterprise/app/controllers/api/v1/accounts/whatsapp_calls_controller.rb
+++ b/enterprise/app/controllers/api/v1/accounts/whatsapp_calls_controller.rb
@@ -1,8 +1,6 @@
class Api::V1::Accounts::WhatsappCallsController < Api::V1::Accounts::BaseController
- PERMISSION_REQUEST_THROTTLE = 5.minutes
-
before_action :set_call, only: %i[show accept reject terminate upload_recording]
- before_action :set_conversation, only: :initiate
+ before_action :set_call_context, only: :initiate
before_action :ensure_calling_enabled, only: :initiate
before_action :ensure_sdp_offer, only: :initiate
before_action :ensure_contact_phone, only: :initiate
@@ -53,7 +51,7 @@ class Api::V1::Accounts::WhatsappCallsController < Api::V1::Accounts::BaseContro
end
def provider_service
- @provider_service ||= @conversation.inbox.channel.provider_service
+ @provider_service ||= @inbox.channel.provider_service
end
def set_call
@@ -61,13 +59,38 @@ class Api::V1::Accounts::WhatsappCallsController < Api::V1::Accounts::BaseContro
authorize @call.conversation, :show?
end
- def set_conversation
+ def set_call_context
+ params[:conversation_id].present? ? set_context_from_conversation : set_context_from_contact
+ end
+
+ def set_context_from_conversation
@conversation = Current.account.conversations.find_by!(display_id: params[:conversation_id])
authorize @conversation, :show?
+ @inbox = @conversation.inbox
+ @contact = @conversation.contact
+ end
+
+ def set_context_from_contact
+ @inbox = Current.account.inboxes.find(params[:inbox_id])
+ authorize @inbox, :show?
+ @contact = Current.account.contacts.find(params[:contact_id])
+ @conversation = conversation_builder.existing_conversation
+ # Authorize the thread the call will land in — after the dial is too late to refuse a ringing call.
+ authorize(@conversation || conversation_builder.new_conversation, :show?)
+ end
+
+ def conversation_builder
+ @conversation_builder ||= Whatsapp::CallConversationBuilder.new(inbox: @inbox, contact: @contact, user: Current.user)
+ end
+
+ # Created only after the dial succeeds, so a failed call leaves no empty thread and there is nothing to
+ # roll back. Re-authorized because a concurrent caller may have created the thread we get back.
+ def open_conversation!
+ (@conversation || conversation_builder.perform!).tap { |conversation| authorize conversation, :show? }
end
def ensure_calling_enabled
- channel = @conversation.inbox.channel
+ channel = @inbox.channel
return if channel.is_a?(Channel::Whatsapp) && channel.voice_enabled?
render_could_not_create_error(I18n.t('errors.whatsapp.calls.not_enabled'))
@@ -80,7 +103,7 @@ class Api::V1::Accounts::WhatsappCallsController < Api::V1::Accounts::BaseContro
end
def ensure_contact_phone
- return if @conversation.contact&.phone_number.present?
+ return if @contact.phone_number.present?
render_could_not_create_error(I18n.t('errors.whatsapp.calls.contact_phone_required'))
end
@@ -105,92 +128,45 @@ class Api::V1::Accounts::WhatsappCallsController < Api::V1::Accounts::BaseContro
end
def create_outbound_call
- contact_phone = @conversation.contact.phone_number.delete('+')
- # Claim for the caller only if unassigned at trigger time (before the round-trip); wins over auto-assignment.
- claim_for_caller = @conversation.assignee_id.nil?
+ # A reused thread unassigned at click time is claimed for the caller (wins over auto-assignment); a
+ # fresh thread (@conversation nil until the dial succeeds) is created already assigned to the caller.
+ claim_for_caller = @conversation.present? && @conversation.assignee_id.nil?
- result = provider_service.initiate_call(contact_phone, params[:sdp_offer])
+ result = provider_service.initiate_call(@contact.phone_number.delete('+'), params[:sdp_offer])
provider_call_id = result.dig('calls', 0, 'id') || result['call_id']
+ @conversation = open_conversation!
@conversation.with_lock { @conversation.update!(assignee: Current.user) } if claim_for_caller
+ create_call_record(provider_call_id)
+ end
+
+ def create_call_record(provider_call_id)
+ existing = Current.account.calls.whatsapp.find_by(provider_call_id: provider_call_id)
+ return existing if existing
+
Current.account.calls.create!(
provider: :whatsapp, inbox: @conversation.inbox, conversation: @conversation, contact: @conversation.contact,
provider_call_id: provider_call_id, direction: :outgoing, status: 'ringing',
accepted_by_agent_id: Current.user.id,
meta: { 'sdp_offer' => params[:sdp_offer], 'ice_servers' => Call.default_ice_servers }
)
+ rescue ActiveRecord::RecordNotUnique
+ # A webhook inserted the row between the find_by above and this create; reconcile to it.
+ Current.account.calls.whatsapp.find_by!(provider_call_id: provider_call_id)
end
- # Meta error 138006 means the contact hasn't opted in yet; send the opt-in
- # template (throttled, behind a conversation lock to prevent double-send).
def render_permission_request
- status = nil
- @conversation.with_lock do
- if permission_request_throttled?
- status = 'permission_pending'
- next
- end
-
- sent = send_permission_request_safely
- if sent
- record_permission_request_wamid(sent)
- emit_permission_requested_activity
- status = 'permission_requested'
- else
- status = 'failed'
- end
- end
+ # Raised mid-dial, so a fresh contact has no thread yet — open one for the opt-in template to land in.
+ @conversation = open_conversation!
+ status = Whatsapp::CallPermissionRequestService.new(conversation: @conversation).perform
return render_could_not_create_error(I18n.t('errors.whatsapp.calls.permission_request_failed')) if status == 'failed'
# 422 (not 200) so any client treating 2xx as "call placed" can't mistake
# the permission-template path for a successful dial. The FE composable
# detects this status and surfaces the banner instead of throwing.
- render json: { status: status }, status: :unprocessable_entity
- end
-
- def permission_request_throttled?
- last_requested = @conversation.additional_attributes&.dig('call_permission_requested_at')
- last_requested.present? && Time.zone.parse(last_requested) > PERMISSION_REQUEST_THROTTLE.ago
- end
-
- # Treat transport errors as a falsy return so we render 422 rather than 500.
- def send_permission_request_safely
- provider_service.send_call_permission_request(
- @conversation.contact.phone_number.delete('+'),
- *permission_request_body_args
- )
- rescue StandardError => e
- Rails.logger.warn "[WHATSAPP CALL] permission_request failed: #{e.class} #{e.message}"
- nil
- end
-
- # Pass the inbox-level override only when present so the provider falls back
- # to the i18n default for inboxes that haven't customized the prompt.
- def permission_request_body_args
- custom_body = @conversation.inbox.channel.provider_config&.dig('call_permission_request_body').presence
- custom_body ? [custom_body] : []
- end
-
- def emit_permission_requested_activity
- content = I18n.t(
- 'conversations.activity.whatsapp_call.permission_requested',
- contact_name: @conversation.contact.name
- )
- ::Conversations::ActivityMessageJob.perform_later(
- @conversation,
- { account_id: @conversation.account_id, inbox_id: @conversation.inbox_id, message_type: :activity, content: content }
- )
- end
-
- # Stash the outbound wamid so the reply webhook can match context.id back here.
- def record_permission_request_wamid(sent)
- attrs = (@conversation.additional_attributes || {}).merge(
- 'call_permission_requested_at' => Time.current.iso8601,
- 'call_permission_request_message_id' => sent.dig('messages', 0, 'id')
- )
- @conversation.update!(additional_attributes: attrs)
+ render json: { status: status, conversation_id: @conversation.display_id }, status: :unprocessable_entity
end
def render_call_error(error)
diff --git a/enterprise/app/controllers/twilio/voice_controller.rb b/enterprise/app/controllers/twilio/voice_controller.rb
index 66fef9583..52ec2637b 100644
--- a/enterprise/app/controllers/twilio/voice_controller.rb
+++ b/enterprise/app/controllers/twilio/voice_controller.rb
@@ -107,8 +107,8 @@ class Twilio::VoiceController < ApplicationController
when 'inbound'
Voice::InboundCallBuilder.perform!(
inbox: inbox,
- from_number: twilio_from,
- call_sid: twilio_call_sid
+ call_sid: twilio_call_sid,
+ caller: { source_ids: [twilio_from], contact_attributes: { name: twilio_from, phone_number: twilio_from } }
)
when 'outbound-api', 'outbound-dial'
sync_outbound_leg(call_sid: twilio_call_sid, direction: twilio_direction)
diff --git a/enterprise/app/services/captain/assistant/session_capture_service.rb b/enterprise/app/services/captain/assistant/session_capture_service.rb
index 36af50308..816fe5355 100644
--- a/enterprise/app/services/captain/assistant/session_capture_service.rb
+++ b/enterprise/app/services/captain/assistant/session_capture_service.rb
@@ -22,13 +22,12 @@ class Captain::Assistant::SessionCaptureService
def capture!
model = @assistant.agent_model
- metadata = context.dig(:state, :cw_metadata) || {}
Captain::AgentSession.create!(
assistant: @assistant,
session_type: :assistant,
subject: @conversation,
- result: @result_message,
+ result: result_message,
llm_model: "#{Llm::Models.provider_for(model)}-#{model}",
credits_consumed: @credits_consumed,
faq_ids: metadata[:faq_ids] || [],
@@ -44,6 +43,23 @@ class Captain::Assistant::SessionCaptureService
@run_result.context || {}
end
+ def metadata
+ @metadata ||= context.dig(:state, :cw_metadata) || {}
+ end
+
+ # On handoff, HandoffTool records the private reason note it created; the session
+ # attaches there so agents can inspect the generation path on the note itself.
+ def result_message
+ handoff_note || @result_message
+ end
+
+ def handoff_note
+ note_id = metadata[:handoff_note_id]
+ return if note_id.blank?
+
+ @conversation.messages.find_by(id: note_id)
+ end
+
def scenario_ids
ids = current_turn_history.filter_map do |message|
next unless message[:role].to_s == 'assistant'
@@ -59,6 +75,11 @@ class Captain::Assistant::SessionCaptureService
def current_turn_history
history = Array(context[:conversation_history])
last_user_index = history.rindex { |message| message[:role].to_s == 'user' }
- last_user_index ? history[last_user_index..] : history
+ current_turn = last_user_index ? history[last_user_index..] : history
+
+ current_turn.map do |message|
+ content = message[:content]
+ content.is_a?(RubyLLM::Content) ? message.merge(content: content.to_h) : message
+ end
end
end
diff --git a/enterprise/app/services/voice/inbound_call_builder.rb b/enterprise/app/services/voice/inbound_call_builder.rb
index eef70e76b..c928da43f 100644
--- a/enterprise/app/services/voice/inbound_call_builder.rb
+++ b/enterprise/app/services/voice/inbound_call_builder.rb
@@ -1,17 +1,19 @@
class Voice::InboundCallBuilder
- attr_reader :inbox, :from_number, :call_sid, :provider, :extra_meta
+ attr_reader :inbox, :call_sid, :provider, :extra_meta, :source_ids, :contact_attributes
- def self.perform!(inbox:, from_number:, call_sid:, provider: :twilio, extra_meta: {})
- new(inbox: inbox, from_number: from_number, call_sid: call_sid,
- provider: provider, extra_meta: extra_meta).perform!
+ # `caller` carries the contact identity: { source_ids:, contact_attributes: }. Twilio passes
+ # its single +phone source_id; WhatsApp passes the message-path phone/user_id/parent_user_id set.
+ def self.perform!(inbox:, call_sid:, caller:, provider: :twilio, extra_meta: {})
+ new(inbox: inbox, call_sid: call_sid, caller: caller, provider: provider, extra_meta: extra_meta).perform!
end
- def initialize(inbox:, from_number:, call_sid:, provider: :twilio, extra_meta: {})
+ def initialize(inbox:, call_sid:, caller:, provider: :twilio, extra_meta: {})
@inbox = inbox
- @from_number = from_number
@call_sid = call_sid
@provider = provider.to_sym
@extra_meta = extra_meta || {}
+ @source_ids = Array(caller[:source_ids]).compact_blank
+ @contact_attributes = caller[:contact_attributes] || {}
end
def perform!
@@ -43,46 +45,17 @@ class Voice::InboundCallBuilder
.find_by(provider: provider, provider_call_id: call_sid)
end
- # Always look up by (inbox, source_id) first — that pair has a UNIQUE index, so
- # creating with a colliding source_id under a different contact would raise
- # RecordNotUnique. Reuse the existing ContactInbox (and its contact) when found.
- # A concurrent message webhook for the same wa_id can win the (inbox_id, source_id)
- # race; rescue and re-find so the call path doesn't drop the connect.
+ # Resolve the contact/ContactInbox the same way inbound messages do — match across every
+ # candidate source_id (phone + BSUID aliases) so a call reuses the existing thread, creating
+ # one keyed on the first (phone, else BSUID) only when none exists. Shared with messaging via
+ # ContactInboxSourceIdResolver, which also rescues the concurrent-webhook create race.
def ensure_contact_inbox!
- sid = source_id_for_provider
- existing = inbox.contact_inboxes.find_by(source_id: sid)
- return existing if existing
-
- ContactInbox.create!(contact: ensure_contact!, inbox: inbox, source_id: sid)
- rescue ActiveRecord::RecordNotUnique
- inbox.contact_inboxes.find_by!(source_id: sid)
+ ContactInboxSourceIdResolver.new(
+ inbox: inbox, source_ids: source_ids, contact_attributes: contact_attributes
+ ).perform
end
- def ensure_contact!
- contact = account.contacts.find_or_create_by!(phone_number: from_number) do |record|
- record.name = contact_name.presence || from_number
- end
- contact.update!(name: contact_name) if contact_name.present? && contact.name == from_number
- contact
- end
-
- # WhatsApp inbound calls carry the caller's profile name in extra_meta; Twilio
- # calls don't, so contact naming falls back to the phone number.
- def contact_name
- extra_meta['contact_name'].presence
- end
-
- # WhatsApp ContactInbox.source_id must be digits-only (the wa_id); Twilio accepts the +.
- # Run BR/AR-style wa_id normalization (same path messaging uses) so an inbound call
- # finds the existing ContactInbox instead of forking a new contact/conversation.
- def source_id_for_provider
- return from_number unless provider == :whatsapp
-
- digits = from_number.to_s.delete_prefix('+')
- Whatsapp::PhoneNumberNormalizationService.new(inbox).normalize_and_find_contact_by_provider(digits, :cloud)
- end
-
- # Mirror incoming-message routing: reuse the open conversation (or the last one when locked), else create new.
+ # Mirror Whatsapp::IncomingMessageBaseService#set_conversation: reuse this row's open conversation (or last when locked), else create.
def resolve_conversation!(contact, contact_inbox)
reusable = if inbox.lock_to_single_conversation
contact_inbox.conversations.last
diff --git a/enterprise/app/services/whatsapp/call_conversation_builder.rb b/enterprise/app/services/whatsapp/call_conversation_builder.rb
new file mode 100644
index 000000000..665f2fb20
--- /dev/null
+++ b/enterprise/app/services/whatsapp/call_conversation_builder.rb
@@ -0,0 +1,32 @@
+class Whatsapp::CallConversationBuilder
+ pattr_initialize [:inbox!, :contact!, :user!]
+
+ # Mirrors the continuity rule in Whatsapp::IncomingMessageBaseService#set_conversation.
+ # Locked inboxes hold a contact to one thread, so the caller is refused rather than given a second one.
+ def existing_conversation
+ return contact_conversations.first if inbox.lock_to_single_conversation
+
+ # Only threads the caller can open, else a newest-but-hidden thread would block the call.
+ Conversations::PermissionFilterService.new(
+ contact_conversations.where.not(status: :resolved), user, inbox.account
+ ).perform.first
+ end
+
+ def contact_conversations
+ inbox.conversations.where(contact_id: contact.id).order(last_activity_at: :desc)
+ end
+
+ # Unsaved, so callers can authorize the thread a call would open before dialing.
+ def new_conversation
+ inbox.account.conversations.new(inbox: inbox, contact: contact, assignee_id: user.id, status: :open)
+ end
+
+ # Locked so two agents calling the same fresh contact can't open two threads.
+ def perform!
+ contact_inbox = ContactInboxBuilder.new(contact: contact, inbox: inbox).perform
+
+ contact_inbox.with_lock do
+ existing_conversation || new_conversation.tap { |conversation| conversation.update!(contact_inbox: contact_inbox) }
+ end
+ end
+end
diff --git a/enterprise/app/services/whatsapp/call_permission_request_service.rb b/enterprise/app/services/whatsapp/call_permission_request_service.rb
new file mode 100644
index 000000000..65c4f1506
--- /dev/null
+++ b/enterprise/app/services/whatsapp/call_permission_request_service.rb
@@ -0,0 +1,63 @@
+# Meta error 138006 means the contact hasn't opted in to calls yet; send the opt-in template.
+class Whatsapp::CallPermissionRequestService
+ THROTTLE = 5.minutes
+
+ pattr_initialize [:conversation!]
+
+ # Locked so two agents calling the same contact can't both send the template.
+ def perform
+ conversation.with_lock do
+ next 'permission_pending' if throttled?
+
+ sent = send_request_safely
+ next 'failed' if sent.blank?
+
+ record_wamid(sent)
+ emit_activity
+ 'permission_requested'
+ end
+ end
+
+ private
+
+ def throttled?
+ last_requested = conversation.additional_attributes&.dig('call_permission_requested_at')
+ last_requested.present? && Time.zone.parse(last_requested) > THROTTLE.ago
+ end
+
+ # Treat transport errors as a falsy return so the caller renders 422 rather than 500.
+ def send_request_safely
+ provider_service.send_call_permission_request(conversation.contact.phone_number.delete('+'), *body_args)
+ rescue StandardError => e
+ Rails.logger.warn "[WHATSAPP CALL] permission_request failed: #{e.class} #{e.message}"
+ nil
+ end
+
+ # Pass the inbox-level override only when present so the provider falls back
+ # to the i18n default for inboxes that haven't customized the prompt.
+ def body_args
+ custom_body = conversation.inbox.channel.provider_config&.dig('call_permission_request_body').presence
+ custom_body ? [custom_body] : []
+ end
+
+ def emit_activity
+ content = I18n.t('conversations.activity.whatsapp_call.permission_requested', contact_name: conversation.contact.name)
+ ::Conversations::ActivityMessageJob.perform_later(
+ conversation,
+ { account_id: conversation.account_id, inbox_id: conversation.inbox_id, message_type: :activity, content: content }
+ )
+ end
+
+ # Stash the outbound wamid so the reply webhook can match context.id back here.
+ def record_wamid(sent)
+ attrs = (conversation.additional_attributes || {}).merge(
+ 'call_permission_requested_at' => Time.current.iso8601,
+ 'call_permission_request_message_id' => sent.dig('messages', 0, 'id')
+ )
+ conversation.update!(additional_attributes: attrs)
+ end
+
+ def provider_service
+ @provider_service ||= conversation.inbox.channel.provider_service
+ end
+end
diff --git a/enterprise/app/services/whatsapp/inbound_call_identity_builder.rb b/enterprise/app/services/whatsapp/inbound_call_identity_builder.rb
new file mode 100644
index 000000000..590a1f923
--- /dev/null
+++ b/enterprise/app/services/whatsapp/inbound_call_identity_builder.rb
@@ -0,0 +1,48 @@
+class Whatsapp::InboundCallIdentityBuilder
+ pattr_initialize [:inbox!, :params!]
+
+ # Build the message path's source_id set (phone wa_id -> user_id -> parent_user_id) plus
+ # contact attributes, so the resolver lands a call on the same ContactInbox a message would.
+ # BSUIDs ride in from_user_id/from_parent_user_id (or the contact's user_id/parent_user_id),
+ # never in `from` (the phone wa_id).
+ def perform(payload)
+ contact = caller_contact(payload)
+ phone = contact[:wa_id].presence || payload[:from].presence
+ source_ids = [
+ phone_source_id(phone),
+ payload[:from_user_id].presence || contact[:user_id].presence,
+ payload[:from_parent_user_id].presence || contact[:parent_user_id].presence
+ ].compact_blank.uniq
+ { source_ids: source_ids, contact_attributes: contact_attributes(contact, phone, source_ids.first) }
+ end
+
+ private
+
+ # Normalize the wa_id the same way messaging does so a call matches its stored source_id.
+ def phone_source_id(phone)
+ return unless phone.to_s.match?(/\A\d{1,15}\z/)
+
+ Whatsapp::PhoneNumberNormalizationService.new(inbox).normalize_and_find_contact_by_provider(phone.to_s, :cloud)
+ end
+
+ def contact_attributes(contact, phone, source_identifier)
+ name = contact.dig(:profile, :name).presence || source_identifier
+ return { name: name } unless phone.to_s.match?(/\A\d{1,15}\z/)
+
+ formatted = "+#{phone}"
+ { name: name == phone ? formatted : name, phone_number: formatted }
+ end
+
+ # Match the contacts entry to THIS caller so batched payloads don't borrow another's identity.
+ def caller_contact(payload)
+ Array(params[:contacts]).map(&:with_indifferent_access).find do |c|
+ identifier_match?(c[:wa_id], payload[:from]) ||
+ identifier_match?(c[:user_id], payload[:from_user_id]) ||
+ identifier_match?(c[:parent_user_id], payload[:from_parent_user_id])
+ end || {}.with_indifferent_access
+ end
+
+ def identifier_match?(left, right)
+ left.present? && right.present? && left.to_s == right.to_s
+ end
+end
diff --git a/enterprise/app/services/whatsapp/incoming_call_service.rb b/enterprise/app/services/whatsapp/incoming_call_service.rb
index 11b35d95a..ea08c8415 100644
--- a/enterprise/app/services/whatsapp/incoming_call_service.rb
+++ b/enterprise/app/services/whatsapp/incoming_call_service.rb
@@ -95,28 +95,21 @@ class Whatsapp::IncomingCallService
# commit) already terminal, never `ringing` — agents aren't rung for a dead call.
def build_inbound_call(payload, sdp_offer)
ActiveRecord::Base.transaction do
- call = Voice::InboundCallBuilder.perform!(inbox: inbox, from_number: "+#{payload[:from]}", call_sid: payload[:id],
- provider: :whatsapp, extra_meta: inbound_extra_meta(payload, sdp_offer))
+ identity = Whatsapp::InboundCallIdentityBuilder.new(inbox: inbox, params: params).perform(payload)
+ extra_meta = { 'sdp_offer' => sdp_offer, 'ice_servers' => Call.default_ice_servers }
+ call = Voice::InboundCallBuilder.perform!(inbox: inbox, call_sid: payload[:id],
+ provider: :whatsapp, extra_meta: extra_meta, caller: identity)
+ sync_caller_identifiers(call, identity)
tombstone = consume_terminate_tombstone(payload[:id])
finalize_terminate(call, tombstone['duration'], tombstone['terminate_reason']) if tombstone
call
end
end
- def inbound_extra_meta(payload, sdp_offer)
- extra_meta = { 'sdp_offer' => sdp_offer, 'ice_servers' => Call.default_ice_servers }
- name = caller_profile_name(payload)
- extra_meta['contact_name'] = name if name.present?
- extra_meta
- end
-
- # Match strictly on wa_id (== calls[].from): in a batched payload missing this
- # call's contact entry, borrowing another caller's name would corrupt this
- # contact, so fall back to the phone number (nil here) instead of contacts.first.
- def caller_profile_name(payload)
- contacts = Array(params[:contacts]).map(&:with_indifferent_access)
- match = contacts.find { |c| c[:wa_id].to_s == payload[:from].to_s }
- match&.dig(:profile, :name).presence
+ # Backfill every caller alias (the builder only stores the first) so a later event keyed on any one lands on this thread.
+ def sync_caller_identifiers(call, identity)
+ Whatsapp::IdentifierSyncService.new(contact_inbox: call.conversation.contact_inbox, contact: call.contact)
+ .perform(source_ids: identity[:source_ids], phone_number: identity.dig(:contact_attributes, :phone_number))
end
# `connect` is the WebRTC tunnel-ready signal, not the pickup signal. Apply
diff --git a/enterprise/app/views/api/v1/accounts/captain/agent_sessions/show.json.jbuilder b/enterprise/app/views/api/v1/accounts/captain/agent_sessions/show.json.jbuilder
new file mode 100644
index 000000000..1e1cd1d7d
--- /dev/null
+++ b/enterprise/app/views/api/v1/accounts/captain/agent_sessions/show.json.jbuilder
@@ -0,0 +1,18 @@
+json.id @agent_session.id
+json.message_id @agent_session.result_id
+json.llm_model @agent_session.llm_model
+json.credits_consumed @agent_session.credits_consumed
+json.run_context @agent_session.run_context.is_a?(Array) ? @agent_session.run_context : []
+json.citations @citations do |citation|
+ json.id citation.id
+ json.title citation.question
+ # display_url resolves uploaded PDFs to their blob URL; external_link holds a
+ # "PDF: ..." placeholder for those. Guard on scheme so placeholders render as
+ # plain text instead of dead anchors.
+ link = citation.documentable.is_a?(Captain::Document) ? citation.documentable.display_url : nil
+ json.link link&.match?(%r{\Ahttps?://}) ? link : nil
+end
+json.scenarios @scenario_titles do |id, title|
+ json.id id
+ json.title title
+end
diff --git a/enterprise/app/views/api/v1/accounts/whatsapp_calls/initiate.json.jbuilder b/enterprise/app/views/api/v1/accounts/whatsapp_calls/initiate.json.jbuilder
index bdb1fa204..920c5bb7d 100644
--- a/enterprise/app/views/api/v1/accounts/whatsapp_calls/initiate.json.jbuilder
+++ b/enterprise/app/views/api/v1/accounts/whatsapp_calls/initiate.json.jbuilder
@@ -2,4 +2,5 @@ json.status 'calling'
json.call_id @call.provider_call_id
json.id @call.id
json.message_id @message.id
+json.conversation_id @conversation.display_id
json.provider 'whatsapp'
diff --git a/enterprise/lib/captain/tools/handoff_tool.rb b/enterprise/lib/captain/tools/handoff_tool.rb
index d126840be..f3ca8b1fe 100644
--- a/enterprise/lib/captain/tools/handoff_tool.rb
+++ b/enterprise/lib/captain/tools/handoff_tool.rb
@@ -13,7 +13,7 @@ class Captain::Tools::HandoffTool < Captain::Tools::BasePublicTool
})
# Use existing handoff mechanism from ResponseBuilderJob
- trigger_handoff(conversation, reason)
+ trigger_handoff(tool_context, conversation, reason)
"Conversation handed off to human support team#{" (Reason: #{reason})" if reason}"
rescue StandardError => e
@@ -23,9 +23,9 @@ class Captain::Tools::HandoffTool < Captain::Tools::BasePublicTool
private
- def trigger_handoff(conversation, reason)
+ def trigger_handoff(tool_context, conversation, reason)
# post the reason as a private note
- conversation.messages.create!(
+ note = conversation.messages.create!(
message_type: :outgoing,
private: true,
sender: @assistant,
@@ -34,6 +34,15 @@ class Captain::Tools::HandoffTool < Captain::Tools::BasePublicTool
content: reason
)
+ # Session capture attributes the run to this note so agents can inspect the
+ # generation path on the handoff reason instead of the canned follow-up message.
+ # A reason-less note has no content and never renders in the dashboard, so
+ # leave it unrecorded and let capture fall back to the follow-up message.
+ if reason.present?
+ metadata = tool_context.state[:cw_metadata] ||= {}
+ metadata[:handoff_note_id] = note.id
+ end
+
# Trigger the bot handoff (sets status to open + dispatches events)
conversation.bot_handoff!
diff --git a/lib/captain/overview_summary_service.rb b/lib/captain/overview_summary_service.rb
index e11132d42..43eb8c24c 100644
--- a/lib/captain/overview_summary_service.rb
+++ b/lib/captain/overview_summary_service.rb
@@ -32,6 +32,7 @@ class Captain::OverviewSummaryService < Captain::BaseTaskService
{
'first_name' => first_name.to_s,
'assistant_name' => assistant.name.to_s,
+ 'language' => account.locale_english_name,
'conversations_handled' => current(:conversations_handled),
'hours_saved' => current(:hours_saved),
'auto_resolution_rate' => current(:auto_resolution_rate),
diff --git a/lib/integrations/openai/openai_prompts/captain_overview_summary.liquid b/lib/integrations/openai/openai_prompts/captain_overview_summary.liquid
index 19c32ed7c..c5637da0f 100644
--- a/lib/integrations/openai/openai_prompts/captain_overview_summary.liquid
+++ b/lib/integrations/openai/openai_prompts/captain_overview_summary.liquid
@@ -1,7 +1,8 @@
You are writing a short, warm summary of how an AI support assistant named "{{ assistant_name }}" performed over a reporting period, for {{ first_name }}, the person who manages it.
Voice and format:
-- Address {{ first_name }} directly and open with "Hey {{ first_name }},". Be conversational, never robotic.
+- Write the entire summary in {{ language }}.
+- Address {{ first_name }} directly and open with a short casual greeting to {{ first_name }} in {{ language }}, the natural equivalent of "Hey {{ first_name }},". Never leave the greeting in English when {{ language }} is not English. Be conversational, never robotic.
- Always call the assistant by its name, {{ assistant_name }}. Never call it "Captain", "the assistant", or "your assistant".
- This is a static, read-only poster on an analytics dashboard, not a chat. The reader cannot reply or ask you for anything. Never ask a question, invite a reply, offer further help, or say things like "let me know" or "I can dive in".
- Write 2 to 4 sentences in one short paragraph. Add a second short paragraph only for a genuinely useful heads-up.
diff --git a/package.json b/package.json
index bf00dde8a..c699787f2 100644
--- a/package.json
+++ b/package.json
@@ -35,7 +35,7 @@
"@breezystack/lamejs": "^1.2.7",
"@chatwoot/ninja-keys": "1.2.3",
"@chatwoot/prosemirror-schema": "1.3.22",
- "@chatwoot/utils": "^0.0.55",
+ "@chatwoot/utils": "^0.0.56",
"@formkit/core": "^1.7.2",
"@formkit/vue": "^1.7.2",
"@hcaptcha/vue3-hcaptcha": "^1.3.0",
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 0ffb85c18..40f84477a 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -28,8 +28,8 @@ importers:
specifier: 1.3.22
version: 1.3.22
'@chatwoot/utils':
- specifier: ^0.0.55
- version: 0.0.55
+ specifier: ^0.0.56
+ version: 0.0.56
'@formkit/core':
specifier: ^1.7.2
version: 1.7.2
@@ -464,8 +464,8 @@ packages:
'@chatwoot/prosemirror-schema@1.3.22':
resolution: {integrity: sha512-0r+PT8xhQLCKCpoV9k9XVTTRECs/0Nr37wbcLsRS7yvc7WkF9FY05z2hGCRJReWmTOcmmshHtb042LVP+MyB/w==}
- '@chatwoot/utils@0.0.55':
- resolution: {integrity: sha512-8G6HYQe1ZEYfJEsSYfDVvE+uhf98JDRjtGlpB+bzMko+yltbrk4yACSo/ImC3jSaJ6K8yPTSjJToSRmsQbL2iQ==}
+ '@chatwoot/utils@0.0.56':
+ resolution: {integrity: sha512-A6dmPLfTSrW4qYNY73btyi4PqpfzcXRSaucscZTQdzNqF6G/QUdgnBmHtho8HeiYby/kSHXaSxLJj+0dx3yEQQ==}
engines: {node: '>=10'}
'@codemirror/commands@6.7.0':
@@ -5154,7 +5154,7 @@ snapshots:
prosemirror-utils: 1.2.2(prosemirror-model@1.22.3)(prosemirror-state@1.4.3)
prosemirror-view: 1.34.1
- '@chatwoot/utils@0.0.55':
+ '@chatwoot/utils@0.0.56':
dependencies:
date-fns: 2.30.0
diff --git a/spec/controllers/api/v1/accounts/agent_bots_controller_spec.rb b/spec/controllers/api/v1/accounts/agent_bots_controller_spec.rb
index a98f787e0..6e1b03bac 100644
--- a/spec/controllers/api/v1/accounts/agent_bots_controller_spec.rb
+++ b/spec/controllers/api/v1/accounts/agent_bots_controller_spec.rb
@@ -64,6 +64,14 @@ RSpec.describe 'Agent Bot API', type: :request do
expect(response).to have_http_status(:success)
expect(response.body).to include(agent_bot.access_token.token)
end
+
+ it 'supports API token authentication' do
+ get "/api/v1/accounts/#{account.id}/agent_bots",
+ headers: { api_access_token: admin.access_token.token },
+ as: :json
+
+ expect(response).to have_http_status(:success)
+ end
end
end
diff --git a/spec/enterprise/controllers/api/v1/accounts/captain/agent_sessions_controller_spec.rb b/spec/enterprise/controllers/api/v1/accounts/captain/agent_sessions_controller_spec.rb
new file mode 100644
index 000000000..1444dc0a8
--- /dev/null
+++ b/spec/enterprise/controllers/api/v1/accounts/captain/agent_sessions_controller_spec.rb
@@ -0,0 +1,120 @@
+require 'rails_helper'
+
+RSpec.describe 'Api::V1::Accounts::Captain::AgentSessions', type: :request do
+ let(:account) { create(:account) }
+ let(:agent) { create(:user, account: account, role: :agent) }
+ let(:inbox) { create(:inbox, account: account) }
+ let(:conversation) { create(:conversation, account: account, inbox: inbox) }
+ let(:assistant) { create(:captain_assistant, account: account) }
+ let(:message) do
+ create(:message, account: account, conversation: conversation, message_type: :outgoing, sender: assistant)
+ end
+
+ before { create(:inbox_member, user: agent, inbox: inbox) }
+
+ def json_response
+ JSON.parse(response.body, symbolize_names: true)
+ end
+
+ describe 'GET /api/v1/accounts/:account_id/captain/agent_sessions/:id' do
+ context 'when it is an unauthenticated user' do
+ it 'returns unauthorized' do
+ get "/api/v1/accounts/#{account.id}/captain/agent_sessions/#{message.id}", as: :json
+
+ expect(response).to have_http_status(:unauthorized)
+ end
+ end
+
+ context 'when the message has an agent session' do
+ let(:document) { create(:captain_document, account: account, assistant: assistant) }
+ let(:documented_faq) do
+ create(:captain_assistant_response, account: account, assistant: assistant,
+ question: 'How do I reset my password?', documentable: document)
+ end
+ let(:plain_faq) do
+ create(:captain_assistant_response, account: account, assistant: assistant, question: 'How do I change my email?')
+ end
+ let(:pdf_document) do
+ create(:captain_document, account: account, assistant: assistant, external_link: nil,
+ pdf_file: Rack::Test::UploadedFile.new(Rails.root.join('spec/assets/sample.pdf'), 'application/pdf'))
+ end
+ let(:pdf_faq) do
+ create(:captain_assistant_response, account: account, assistant: assistant,
+ question: 'What are the pricing tiers?', documentable: pdf_document)
+ end
+ let(:scenario) { create(:captain_scenario, account: account, assistant: assistant, title: 'Refund flow') }
+ let(:run_context) do
+ [
+ { 'role' => 'user', 'content' => 'I want a refund' },
+ { 'role' => 'assistant', 'content' => '', 'agent_name' => 'Assistant',
+ 'tool_calls' => [{ 'id' => 'call_1', 'name' => 'faq_lookup', 'arguments' => { 'query' => 'refund' } }] },
+ { 'role' => 'tool', 'content' => 'Refunds take 5 days', 'tool_call_id' => 'call_1' },
+ { 'role' => 'assistant', 'content' => 'Refunds take 5 days', 'agent_name' => "scenario_#{scenario.id}_refund_flow" }
+ ]
+ end
+ let!(:agent_session) do
+ create(:captain_agent_session, account: account, assistant: assistant,
+ subject: conversation, result: message,
+ llm_model: 'openai-gpt-5.2', credits_consumed: 1.0,
+ faq_ids: [documented_faq.id, plain_faq.id, pdf_faq.id, documented_faq.id + 100_000],
+ scenario_ids: [scenario.id],
+ run_context: run_context)
+ end
+
+ it 'returns the session with hydrated citations and scenarios' do
+ get "/api/v1/accounts/#{account.id}/captain/agent_sessions/#{message.id}",
+ headers: agent.create_new_auth_token, as: :json
+
+ expect(response).to have_http_status(:success)
+ aggregate_failures do
+ expect(json_response[:id]).to eq(agent_session.id)
+ expect(json_response[:message_id]).to eq(message.id)
+ expect(json_response[:llm_model]).to eq('openai-gpt-5.2')
+ expect(json_response[:credits_consumed]).to eq(1.0)
+ expect(json_response[:run_context].length).to eq(4)
+ expect(json_response[:run_context].second[:tool_calls].first[:arguments][:query]).to eq('refund')
+
+ citations = json_response[:citations].index_by { |citation| citation[:id] }
+ expect(citations.keys).to contain_exactly(documented_faq.id, plain_faq.id, pdf_faq.id)
+ expect(citations[documented_faq.id][:title]).to eq('How do I reset my password?')
+ expect(citations[documented_faq.id][:link]).to eq(document.external_link)
+ expect(citations[plain_faq.id][:link]).to be_nil
+ expect(pdf_document.external_link).to start_with('PDF:')
+ expect(citations[pdf_faq.id][:link]).to eq(pdf_document.display_url)
+ expect(citations[pdf_faq.id][:link]).to match(%r{\Ahttps?://})
+
+ expect(json_response[:scenarios]).to eq([{ id: scenario.id, title: 'Refund flow' }])
+ end
+ end
+
+ it 'does not allow an agent without access to the conversation' do
+ other_agent = create(:user, account: account, role: :agent)
+
+ get "/api/v1/accounts/#{account.id}/captain/agent_sessions/#{message.id}",
+ headers: other_agent.create_new_auth_token, as: :json
+
+ expect(response).to have_http_status(:unauthorized)
+ end
+ end
+
+ context 'when the message has no agent session' do
+ it 'returns not found' do
+ get "/api/v1/accounts/#{account.id}/captain/agent_sessions/#{message.id}",
+ headers: agent.create_new_auth_token, as: :json
+
+ expect(response).to have_http_status(:not_found)
+ end
+ end
+
+ context 'when the message does not belong to the account' do
+ it 'returns not found' do
+ other_message = create(:message)
+
+ get "/api/v1/accounts/#{account.id}/captain/agent_sessions/#{other_message.id}",
+ headers: agent.create_new_auth_token, as: :json
+
+ expect(response).to have_http_status(:not_found)
+ end
+ end
+ end
+end
diff --git a/spec/enterprise/controllers/api/v1/accounts/captain/assistants_controller_spec.rb b/spec/enterprise/controllers/api/v1/accounts/captain/assistants_controller_spec.rb
index afb6aa2de..c43924fc4 100644
--- a/spec/enterprise/controllers/api/v1/accounts/captain/assistants_controller_spec.rb
+++ b/spec/enterprise/controllers/api/v1/accounts/captain/assistants_controller_spec.rb
@@ -257,10 +257,20 @@ RSpec.describe 'Api::V1::Accounts::Captain::Assistants', type: :request do
let(:alice) { create(:user, account: account, role: :administrator, name: 'Alice Adams') }
let(:bob) { create(:user, account: account, role: :administrator, name: 'Bob Brown') }
let(:summary_service) { instance_double(Captain::OverviewSummaryService) }
+ let(:summary_stats) do
+ {
+ conversations_handled: { current: 42 },
+ hours_saved: { current: 12 },
+ auto_resolution_rate: { current: 65.0, trend: 5.0 },
+ handoff_rate: { current: 20.0, trend: -2.0 },
+ reopen_rate: { current: 5.0, trend: -1.0 },
+ knowledge: { coverage: 80, approved: 8, documents: 3 }
+ }
+ end
def get_summary(user)
get "/api/v1/accounts/#{account.id}/captain/assistants/#{assistant.id}/summary",
- params: { range: '30' },
+ params: { range: '30', stats: summary_stats },
headers: user.create_new_auth_token,
as: :json
end
@@ -273,6 +283,7 @@ RSpec.describe 'Api::V1::Accounts::Captain::Assistants', type: :request do
it 'caches the summary per viewer so one user never receives another user\'s greeting' do
allow(summary_service).to receive(:perform).and_return({ message: 'Hi Alice' })
+ expect(Captain::AssistantStatsBuilder).not_to receive(:new)
get_summary(alice)
get_summary(alice) # served from Alice's cache, no regeneration
@@ -280,6 +291,7 @@ RSpec.describe 'Api::V1::Accounts::Captain::Assistants', type: :request do
expect(response).to have_http_status(:success)
expect(Captain::OverviewSummaryService).to have_received(:new).twice
+ expect(Captain::OverviewSummaryService).to have_received(:new).with(hash_including(stats: summary_stats)).twice
end
it 'does not cache failures so a transient error is retried' do
diff --git a/spec/enterprise/controllers/twilio/voice_controller_spec.rb b/spec/enterprise/controllers/twilio/voice_controller_spec.rb
index 79fdd67a8..0f537af20 100644
--- a/spec/enterprise/controllers/twilio/voice_controller_spec.rb
+++ b/spec/enterprise/controllers/twilio/voice_controller_spec.rb
@@ -33,8 +33,8 @@ RSpec.describe 'Twilio::VoiceController', type: :request do
expect(Voice::InboundCallBuilder).to receive(:perform!).with(
inbox: inbox,
- from_number: from_number,
- call_sid: call_sid
+ call_sid: call_sid,
+ caller: { source_ids: [from_number], contact_attributes: { name: from_number, phone_number: from_number } }
).and_return(call)
post "/twilio/voice/call/#{digits}", params: {
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 eb1cb641c..08bb2a50d 100644
--- a/spec/enterprise/jobs/captain/conversation/response_builder_job_spec.rb
+++ b/spec/enterprise/jobs/captain/conversation/response_builder_job_spec.rb
@@ -561,6 +561,22 @@ RSpec.describe Captain::Conversation::ResponseBuilderJob, type: :job do
expect(account.reload.usage_limits[:captain][:responses][:consumed]).to eq(0)
end
+ it 'attributes the handoff session to the private reason note when the tool recorded one' do
+ handoff_note = create(:message, conversation: conversation, account: account, message_type: :outgoing,
+ private: true, sender: assistant, content: 'Needs a human')
+ run_context[:state][:cw_metadata][:handoff_note_id] = handoff_note.id
+ allow(mock_agent_runner_service).to receive(:generate_response) do
+ conversation.update!(status: :open)
+ { 'response' => 'Let me connect you', 'handoff_tool_called' => true }
+ end
+
+ described_class.perform_now(conversation, assistant)
+
+ session = Captain::AgentSession.last
+ expect(session.credits_consumed).to eq(0.0)
+ expect(session.result_id).to eq(handoff_note.id)
+ end
+
it 'creates a zero-credit session when the handoff tool fired but failed to commit' do
allow(mock_agent_runner_service).to receive(:generate_response).and_return({
'response' => 'I tried to hand off',
diff --git a/spec/enterprise/lib/captain/tools/handoff_tool_spec.rb b/spec/enterprise/lib/captain/tools/handoff_tool_spec.rb
index 492d24f32..db5ee462c 100644
--- a/spec/enterprise/lib/captain/tools/handoff_tool_spec.rb
+++ b/spec/enterprise/lib/captain/tools/handoff_tool_spec.rb
@@ -86,6 +86,12 @@ RSpec.describe Captain::Tools::HandoffTool, type: :model do
tool.perform(tool_context, reason: reason)
end
+
+ it 'records the handoff note id in the run state for session capture' do
+ tool.perform(tool_context, reason: 'Customer needs specialized support')
+
+ expect(tool_context.state[:cw_metadata][:handoff_note_id]).to eq(Message.last.id)
+ end
end
context 'without reason provided' do
@@ -107,6 +113,12 @@ RSpec.describe Captain::Tools::HandoffTool, type: :model do
tool.perform(tool_context)
end
+
+ it 'does not record a handoff note id since the empty note never renders' do
+ tool.perform(tool_context)
+
+ expect(tool_context.state[:cw_metadata]).to be_nil
+ end
end
context 'when handoff fails' do
diff --git a/spec/enterprise/services/captain/assistant/session_capture_service_spec.rb b/spec/enterprise/services/captain/assistant/session_capture_service_spec.rb
index ef25b1e2b..daf38c8d6 100644
--- a/spec/enterprise/services/captain/assistant/session_capture_service_spec.rb
+++ b/spec/enterprise/services/captain/assistant/session_capture_service_spec.rb
@@ -111,6 +111,25 @@ RSpec.describe Captain::Assistant::SessionCaptureService do
expect(history.first).to include('role' => 'user', 'content' => 'CUST001')
end
+ it 'stores multimodal content without cached attachment bytes' do
+ content = RubyLLM::Content.new('See image', ['https://example.com/image.jpg'])
+ content.attachments.first.instance_variable_set(:@content, "\xFF\xD8\xFF\xE0JFIF".b)
+ run_context[:conversation_history] = [
+ { role: :user, content: content },
+ { role: :assistant, content: 'I can see the image', agent_name: 'Assistant' }
+ ]
+
+ history = service.capture!.run_context
+
+ expect(history.first).to include(
+ 'role' => 'user',
+ 'content' => {
+ 'text' => 'See image',
+ 'attachments' => [{ 'type' => 'image', 'source' => 'https://example.com/image.jpg' }]
+ }
+ )
+ end
+
it 'stores the full history when it contains no user message' do
run_context[:conversation_history] = conversation_history.reject { |message| message[:role] == :user }
diff --git a/spec/enterprise/services/voice/inbound_call_builder_spec.rb b/spec/enterprise/services/voice/inbound_call_builder_spec.rb
index e36c9a1b7..c8c6b978e 100644
--- a/spec/enterprise/services/voice/inbound_call_builder_spec.rb
+++ b/spec/enterprise/services/voice/inbound_call_builder_spec.rb
@@ -17,8 +17,8 @@ RSpec.describe Voice::InboundCallBuilder do
def perform_builder
described_class.perform!(
inbox: inbox,
- from_number: from_number,
- call_sid: call_sid
+ call_sid: call_sid,
+ caller: { source_ids: [from_number], contact_attributes: { name: from_number, phone_number: from_number } }
)
end
@@ -100,26 +100,29 @@ RSpec.describe Voice::InboundCallBuilder do
end
end
- context 'when the WhatsApp wa_id needs Brazil normalization to match an existing ContactInbox' do
+ context 'when a WhatsApp call shares a BSUID with an existing ContactInbox' do
let(:whatsapp_channel) do
create(:channel_whatsapp, account: account, provider: 'whatsapp_cloud',
provider_config: { 'phone_number_id' => '123', 'source' => 'embedded_signup', 'calling_enabled' => true },
validate_provider_config: false, sync_templates: false)
end
let(:whatsapp_inbox) { whatsapp_channel.inbox }
- let!(:stored_contact) { create(:contact, account: account, phone_number: '+5541988887777') }
+ let!(:stored_contact) { create(:contact, account: account) }
let!(:stored_contact_inbox) do
- create(:contact_inbox, contact: stored_contact, inbox: whatsapp_inbox, source_id: '5541988887777')
+ create(:contact_inbox, contact: stored_contact, inbox: whatsapp_inbox, source_id: 'IN.2081978709342942')
end
before { account.enable_features!('channel_voice') }
- it 'reuses the contact via normalized wa_id rather than forking a new ContactInbox' do
+ # Closes the gap: the contact was keyed by BSUID, but the call also carries a phone.
+ # Matching across every source_id reuses the contact instead of forking on the phone.
+ it 'reuses the contact by matching any source_id, not just the first' do
call = described_class.perform!(
inbox: whatsapp_inbox,
- from_number: '+554188887777',
- call_sid: 'wacall_br_1',
- provider: :whatsapp
+ call_sid: 'wacall_bsuid_1',
+ provider: :whatsapp,
+ caller: { source_ids: ['5541988887777', 'IN.2081978709342942'],
+ contact_attributes: { name: 'Ada Lovelace', phone_number: '+5541988887777' } }
)
expect(call.contact).to eq(stored_contact)
diff --git a/spec/enterprise/services/whatsapp/incoming_call_service_spec.rb b/spec/enterprise/services/whatsapp/incoming_call_service_spec.rb
index a3c5246d2..cf031f1ca 100644
--- a/spec/enterprise/services/whatsapp/incoming_call_service_spec.rb
+++ b/spec/enterprise/services/whatsapp/incoming_call_service_spec.rb
@@ -74,6 +74,120 @@ describe Whatsapp::IncomingCallService do
end
end
+ describe 'inbound connect from a username (BSUID) caller' do
+ let(:sdp_offer) { "v=0\r\n...sdp..." }
+ let(:bsuid) { 'IN.2081978709342942' }
+ let!(:agent) { create(:user, account: account) }
+
+ before { create(:inbox_member, inbox: inbox, user: agent) }
+
+ it 'keys a phone caller by the phone (matching messaging) even when a BSUID is also present' do
+ allow(ActionCable.server).to receive(:broadcast)
+
+ params = {
+ calls: [{ id: provider_call_id, from: from_number, from_user_id: bsuid, event: 'connect',
+ session: { sdp: sdp_offer, sdp_type: 'offer' } }],
+ contacts: [{ wa_id: from_number, user_id: bsuid, profile: { name: 'Ada Lovelace' } }]
+ }
+ expect { described_class.new(inbox: inbox, params: params).perform }
+ .to change(Call, :count).by(1).and change(Conversation, :count).by(1)
+
+ contact_inbox = Call.last.conversation.contact_inbox
+ expect(contact_inbox.source_id).to eq(from_number)
+ expect(contact_inbox.contact.name).to eq('Ada Lovelace')
+ end
+
+ it 'keys a username-only caller by the BSUID when no phone `from` is present' do
+ allow(ActionCable.server).to receive(:broadcast)
+
+ params = {
+ calls: [{ id: provider_call_id, from_user_id: bsuid, event: 'connect',
+ session: { sdp: sdp_offer, sdp_type: 'offer' } }],
+ contacts: [{ user_id: bsuid, profile: { name: 'Ada Lovelace' } }]
+ }
+ expect { described_class.new(inbox: inbox, params: params).perform }
+ .to change(Call, :count).by(1)
+
+ contact_inbox = Call.last.conversation.contact_inbox
+ expect(contact_inbox.source_id).to eq(bsuid)
+ expect(contact_inbox.contact.name).to eq('Ada Lovelace')
+ end
+
+ it 'reuses the phone-keyed ContactInbox messaging created for a phone caller and backfills the BSUID alias' do
+ allow(ActionCable.server).to receive(:broadcast)
+ contact = create(:contact, account: account)
+ existing = create(:contact_inbox, inbox: inbox, contact: contact, source_id: from_number)
+
+ params = {
+ calls: [{ id: provider_call_id, from: from_number, from_user_id: bsuid, event: 'connect',
+ session: { sdp: sdp_offer, sdp_type: 'offer' } }],
+ contacts: [{ wa_id: from_number, user_id: bsuid }]
+ }
+ # The conversation reuses the existing phone thread; the BSUID alias is backfilled onto the same contact.
+ expect { described_class.new(inbox: inbox, params: params).perform }
+ .to change(Call, :count).by(1).and change(ContactInbox, :count).by(1)
+
+ expect(Call.last.contact).to eq(contact)
+ expect(Call.last.conversation.contact_inbox).to eq(existing)
+ expect(inbox.contact_inboxes.find_by(source_id: bsuid).contact).to eq(contact)
+ end
+
+ it 'reuses a phone ContactInbox via the same wa_id normalization messaging uses' do
+ allow(ActionCable.server).to receive(:broadcast)
+ contact = create(:contact, account: account, phone_number: '+5541988887777')
+ existing = create(:contact_inbox, inbox: inbox, contact: contact, source_id: '5541988887777')
+
+ params = {
+ calls: [{ id: provider_call_id, from: '554188887777', event: 'connect',
+ session: { sdp: sdp_offer, sdp_type: 'offer' } }],
+ contacts: [{ wa_id: '554188887777' }]
+ }
+ expect { described_class.new(inbox: inbox, params: params).perform }
+ .to change(Call, :count).by(1).and not_change(ContactInbox, :count)
+
+ expect(Call.last.conversation.contact_inbox).to eq(existing)
+ end
+
+ it 'reuses the BSUID-keyed ContactInbox messaging created for a username-only caller' do
+ allow(ActionCable.server).to receive(:broadcast)
+ contact = create(:contact, account: account)
+ existing = create(:contact_inbox, inbox: inbox, contact: contact, source_id: bsuid)
+
+ params = {
+ calls: [{ id: provider_call_id, from_user_id: bsuid, event: 'connect',
+ session: { sdp: sdp_offer, sdp_type: 'offer' } }],
+ contacts: [{ user_id: bsuid }]
+ }
+ expect { described_class.new(inbox: inbox, params: params).perform }
+ .to change(Call, :count).by(1).and not_change(ContactInbox, :count)
+
+ expect(Call.last.contact).to eq(contact)
+ expect(Call.last.conversation.contact_inbox).to eq(existing)
+ end
+
+ # The gap: messaging created the contact username-only (BSUID-keyed), and the call now
+ # also exposes a phone. Matching across every source_id reuses the BSUID thread instead
+ # of forking a new phone-keyed contact.
+ it 'reuses a BSUID-keyed ContactInbox even when the call also carries a phone and backfills the phone alias' do
+ allow(ActionCable.server).to receive(:broadcast)
+ contact = create(:contact, account: account)
+ existing = create(:contact_inbox, inbox: inbox, contact: contact, source_id: bsuid)
+
+ params = {
+ calls: [{ id: provider_call_id, from: from_number, from_user_id: bsuid, event: 'connect',
+ session: { sdp: sdp_offer, sdp_type: 'offer' } }],
+ contacts: [{ wa_id: from_number, user_id: bsuid }]
+ }
+ # The conversation reuses the existing BSUID thread; the phone alias is backfilled onto the same contact.
+ expect { described_class.new(inbox: inbox, params: params).perform }
+ .to change(Call, :count).by(1).and change(ContactInbox, :count).by(1)
+
+ expect(Call.last.contact).to eq(contact)
+ expect(Call.last.conversation.contact_inbox).to eq(existing)
+ expect(inbox.contact_inboxes.find_by(source_id: from_number).contact).to eq(contact)
+ end
+ end
+
describe 'outbound connect (existing call)' do
let!(:call) do
conversation = create(:conversation, account: account, inbox: inbox)
diff --git a/spec/services/whatsapp/incoming_message_service_spec.rb b/spec/services/whatsapp/incoming_message_service_spec.rb
index 430aa1561..01b569cb9 100644
--- a/spec/services/whatsapp/incoming_message_service_spec.rb
+++ b/spec/services/whatsapp/incoming_message_service_spec.rb
@@ -34,8 +34,8 @@ describe Whatsapp::IncomingMessageService do
it 'appends to last conversation when if conversation already exists' do
contact_inbox = create(:contact_inbox, inbox: whatsapp_channel.inbox, source_id: params[:messages].first[:from])
- 2.times.each { create(:conversation, inbox: whatsapp_channel.inbox, contact_inbox: contact_inbox) }
- last_conversation = create(:conversation, inbox: whatsapp_channel.inbox, contact_inbox: contact_inbox)
+ 2.times.each { create(:conversation, inbox: whatsapp_channel.inbox, contact_inbox: contact_inbox, contact: contact_inbox.contact) }
+ last_conversation = create(:conversation, inbox: whatsapp_channel.inbox, contact_inbox: contact_inbox, contact: contact_inbox.contact)
described_class.new(inbox: whatsapp_channel.inbox, params: params).perform
# no new conversation should be created
expect(whatsapp_channel.inbox.conversations.count).to eq(3)
@@ -46,7 +46,7 @@ describe Whatsapp::IncomingMessageService do
it 'reopen last conversation if last conversation is resolved and lock to single conversation is enabled' do
whatsapp_channel.inbox.update(lock_to_single_conversation: true)
contact_inbox = create(:contact_inbox, inbox: whatsapp_channel.inbox, source_id: params[:messages].first[:from])
- last_conversation = create(:conversation, inbox: whatsapp_channel.inbox, contact_inbox: contact_inbox)
+ last_conversation = create(:conversation, inbox: whatsapp_channel.inbox, contact_inbox: contact_inbox, contact: contact_inbox.contact)
last_conversation.update(status: 'resolved')
described_class.new(inbox: whatsapp_channel.inbox, params: params).perform
# no new conversation should be created
@@ -59,7 +59,7 @@ describe Whatsapp::IncomingMessageService do
it 'creates a new conversation if last conversation is resolved and lock to single conversation is disabled' do
whatsapp_channel.inbox.update(lock_to_single_conversation: false)
contact_inbox = create(:contact_inbox, inbox: whatsapp_channel.inbox, source_id: params[:messages].first[:from])
- last_conversation = create(:conversation, inbox: whatsapp_channel.inbox, contact_inbox: contact_inbox)
+ last_conversation = create(:conversation, inbox: whatsapp_channel.inbox, contact_inbox: contact_inbox, contact: contact_inbox.contact)
last_conversation.update(status: 'resolved')
described_class.new(inbox: whatsapp_channel.inbox, params: params).perform
# new conversation should be created
@@ -70,7 +70,7 @@ describe Whatsapp::IncomingMessageService do
it 'will not create a new conversation if last conversation is not resolved and lock to single conversation is disabled' do
whatsapp_channel.inbox.update(lock_to_single_conversation: false)
contact_inbox = create(:contact_inbox, inbox: whatsapp_channel.inbox, source_id: params[:messages].first[:from])
- last_conversation = create(:conversation, inbox: whatsapp_channel.inbox, contact_inbox: contact_inbox)
+ last_conversation = create(:conversation, inbox: whatsapp_channel.inbox, contact_inbox: contact_inbox, contact: contact_inbox.contact)
last_conversation.update(status: Conversation.statuses.except('resolved').keys.sample)
described_class.new(inbox: whatsapp_channel.inbox, params: params).perform
# new conversation should be created
@@ -238,7 +238,7 @@ describe Whatsapp::IncomingMessageService do
end
before do
- create(:conversation, inbox: whatsapp_channel.inbox, contact_inbox: contact_inbox)
+ create(:conversation, inbox: whatsapp_channel.inbox, contact_inbox: contact_inbox, contact: contact_inbox.contact)
described_class.new(inbox: whatsapp_channel.inbox, params: params).perform
end
@@ -453,7 +453,7 @@ describe Whatsapp::IncomingMessageService do
it 'appends to existing contact if contact inbox exists' do
contact_inbox = create(:contact_inbox, inbox: whatsapp_channel.inbox, source_id: wa_id)
- last_conversation = create(:conversation, inbox: whatsapp_channel.inbox, contact_inbox: contact_inbox)
+ last_conversation = create(:conversation, inbox: whatsapp_channel.inbox, contact_inbox: contact_inbox, contact: contact_inbox.contact)
described_class.new(inbox: whatsapp_channel.inbox, params: params).perform
# no new conversation should be created
expect(whatsapp_channel.inbox.conversations.count).to eq(1)
@@ -468,7 +468,7 @@ describe Whatsapp::IncomingMessageService do
context 'when a contact inbox exists in the old format without 9 included' do
it 'appends to existing contact' do
contact_inbox = create(:contact_inbox, inbox: whatsapp_channel.inbox, source_id: wa_id)
- last_conversation = create(:conversation, inbox: whatsapp_channel.inbox, contact_inbox: contact_inbox)
+ last_conversation = create(:conversation, inbox: whatsapp_channel.inbox, contact_inbox: contact_inbox, contact: contact_inbox.contact)
described_class.new(inbox: whatsapp_channel.inbox, params: params).perform
# no new conversation should be created
expect(whatsapp_channel.inbox.conversations.count).to eq(1)
@@ -480,7 +480,7 @@ describe Whatsapp::IncomingMessageService do
context 'when a contact inbox exists in the new format with 9 included' do
it 'appends to existing contact' do
contact_inbox = create(:contact_inbox, inbox: whatsapp_channel.inbox, source_id: '5541988887777')
- last_conversation = create(:conversation, inbox: whatsapp_channel.inbox, contact_inbox: contact_inbox)
+ last_conversation = create(:conversation, inbox: whatsapp_channel.inbox, contact_inbox: contact_inbox, contact: contact_inbox.contact)
described_class.new(inbox: whatsapp_channel.inbox, params: params).perform
# no new conversation should be created
expect(whatsapp_channel.inbox.conversations.count).to eq(1)
@@ -515,7 +515,7 @@ describe Whatsapp::IncomingMessageService do
# Normalized format removes the 9 after country code
normalized_wa_id = '541123456789'
contact_inbox = create(:contact_inbox, inbox: whatsapp_channel.inbox, source_id: normalized_wa_id)
- last_conversation = create(:conversation, inbox: whatsapp_channel.inbox, contact_inbox: contact_inbox)
+ last_conversation = create(:conversation, inbox: whatsapp_channel.inbox, contact_inbox: contact_inbox, contact: contact_inbox.contact)
described_class.new(inbox: whatsapp_channel.inbox, params: params).perform
# no new conversation should be created
expect(whatsapp_channel.inbox.conversations.count).to eq(1)
@@ -532,7 +532,7 @@ describe Whatsapp::IncomingMessageService do
context 'when a contact inbox exists with the same format' do
it 'appends to existing contact' do
contact_inbox = create(:contact_inbox, inbox: whatsapp_channel.inbox, source_id: wa_id)
- last_conversation = create(:conversation, inbox: whatsapp_channel.inbox, contact_inbox: contact_inbox)
+ last_conversation = create(:conversation, inbox: whatsapp_channel.inbox, contact_inbox: contact_inbox, contact: contact_inbox.contact)
described_class.new(inbox: whatsapp_channel.inbox, params: params).perform
# no new conversation should be created
expect(whatsapp_channel.inbox.conversations.count).to eq(1)