From 4f7bdebdeb962caddf893dd107e4cbf5d13908ca Mon Sep 17 00:00:00 2001
From: Tomas Bulva <tbulva@gitlab.com>
Date: Thu, 11 Sep 2025 11:48:56 +0200
Subject: [PATCH 1/8] WIP

---
 .../ai/components/duo_chat_logging_alert.vue  | 129 ++++++
 ee/app/assets/javascripts/ai/constants.js     |   1 +
 .../ai/duo_agentic_chat/components/app.vue    |  12 +-
 .../javascripts/ai/duo_agentic_chat/index.js  |  15 +
 .../ai/tanuki_bot/components/app.vue          |  13 +-
 .../assets/javascripts/ai/tanuki_bot/index.js |  17 +-
 .../views/layouts/_tanuki_bot_chat.html.haml  |  11 +-
 .../components/duo_chat_logging_alert_spec.js | 230 +++++++++++
 .../duo_agentic_chat/components/app_spec.js   | 386 +++++++++++++++++-
 .../ai/tanuki_bot/components/app_spec.js      |  41 +-
 locale/gitlab.pot                             |  18 +
 11 files changed, 845 insertions(+), 28 deletions(-)
 create mode 100644 ee/app/assets/javascripts/ai/components/duo_chat_logging_alert.vue
 create mode 100644 ee/spec/frontend/ai/components/duo_chat_logging_alert_spec.js

diff --git a/ee/app/assets/javascripts/ai/components/duo_chat_logging_alert.vue b/ee/app/assets/javascripts/ai/components/duo_chat_logging_alert.vue
new file mode 100644
index 00000000000000..883252433d05b9
--- /dev/null
+++ b/ee/app/assets/javascripts/ai/components/duo_chat_logging_alert.vue
@@ -0,0 +1,129 @@
+<script>
+import { GlAlert, GlSprintf } from '@gitlab/ui';
+import { getCookie, setCookie } from '~/lib/utils/common_utils';
+import { DUO_AGENTIC_CHAT_LOGGING_ALERT } from 'ee/ai/constants';
+
+export default {
+  name: 'DuoChatLoggingAlert',
+  components: {
+    GlAlert,
+    GlSprintf,
+  },
+  props: {
+    metadata: {
+      type: Object,
+      required: false,
+      default: null,
+    },
+  },
+  data() {
+    return {
+      isDismissed: true,
+    };
+  },
+  computed: {
+    hasAlert() {
+      return this.metadata?.isTeamMember && this.metadata?.extendedLogging && !this.isDismissed;
+    },
+  },
+  mounted() {
+    this.getLoggingAlertDismissState();
+  },
+  methods: {
+    onDismiss() {
+      setCookie(DUO_AGENTIC_CHAT_LOGGING_ALERT, true);
+      this.isDismissed = true;
+    },
+    getLoggingAlertDismissState() {
+      this.isDismissed = getCookie(DUO_AGENTIC_CHAT_LOGGING_ALERT) === 'true';
+    },
+  },
+};
+</script>
+
+<template>
+  <gl-alert
+    v-if="hasAlert"
+    :dismissible="true"
+    variant="warning"
+    class="gl-border-t"
+    role="alert"
+    data-testid="duo-alert-logging"
+    :title="__('GitLab Team Member Notice: Chat Logging Active')"
+    primary-button-link="https://internal.gitlab.com/handbook/product/ai-strategy/duo-logging/#logging-duo-chat-usage-by-gitlab-team-members-without-logging-their-names-or-user-id"
+    :primary-button-text="__('Learn more')"
+    @dismiss="onDismiss"
+  >
+    <ul class="gl-list-none gl-pl-0">
+      <li class="gl-mt-3">
+        <gl-sprintf
+          :message="
+            __(
+              '%{bStart}What\'s logged:%{bEnd} Your questions, contexts (files, issues, MRs, etc.), and Duo\'s responses',
+            )
+          "
+        >
+          <template #b="{ content }">
+            <strong>{{ content }}</strong>
+          </template>
+        </gl-sprintf>
+      </li>
+
+      <li class="gl-mt-3">
+        <gl-sprintf
+          :message="
+            __(
+              '%{bStart}Which interfaces are affected:%{bEnd} usage of Duo Chat in Web and IDEs as well as Duo Agentic Chat in Web and IDEs',
+            )
+          "
+        >
+          <template #b="{ content }">
+            <strong>{{ content }}</strong>
+          </template>
+        </gl-sprintf>
+      </li>
+
+      <li class="gl-mt-3">
+        <gl-sprintf
+          :message="
+            __(
+              '%{bStart}Privacy safeguards:%{bEnd} Your name and user ID are not logged as structured fields',
+            )
+          "
+        >
+          <template #b="{ content }">
+            <strong>{{ content }}</strong>
+          </template>
+        </gl-sprintf>
+      </li>
+
+      <li class="gl-mt-3">
+        <gl-sprintf
+          :message="
+            __(
+              '%{bStart}Purpose:%{bEnd} This data helps us improve Duo Chat and will never be used for performance evaluation. Note: The in-app feedback form states \'GitLab team members cannot see the AI content.\' This does not apply for team members\' interactions with the chat.',
+            )
+          "
+        >
+          <template #b="{ content }">
+            <strong>{{ content }}</strong>
+          </template>
+        </gl-sprintf>
+      </li>
+
+      <li class="gl-mt-3">
+        <gl-sprintf
+          :message="
+            __(
+              '%{bStart}Customers are not affected:%{bEnd} we never log customer usage of Duo Chat (unless specifically requested by the customer)',
+            )
+          "
+        >
+          <template #b="{ content }">
+            <strong>{{ content }}</strong>
+          </template>
+        </gl-sprintf>
+      </li>
+    </ul>
+  </gl-alert>
+</template>
diff --git a/ee/app/assets/javascripts/ai/constants.js b/ee/app/assets/javascripts/ai/constants.js
index 18a76efdd622eb..8cf65cd58b6e85 100644
--- a/ee/app/assets/javascripts/ai/constants.js
+++ b/ee/app/assets/javascripts/ai/constants.js
@@ -56,3 +56,4 @@ export const DUO_WORKFLOW_ADDITIONAL_CONTEXT_REPOSITORY = 'repository';
 export const DUO_CURRENT_WORKFLOW_STORAGE_KEY = 'agenticChat.currentWorkflow';
 
 export const DUO_AGENTIC_CHAT_SELECTED_MODEL_KEY = 'agentic-chat-user-selected-model';
+export const DUO_AGENTIC_CHAT_LOGGING_ALERT = 'duo_agentic_chat_logging_alert';
diff --git a/ee/app/assets/javascripts/ai/duo_agentic_chat/components/app.vue b/ee/app/assets/javascripts/ai/duo_agentic_chat/components/app.vue
index 41572df1334389..bdb537d828fbef 100644
--- a/ee/app/assets/javascripts/ai/duo_agentic_chat/components/app.vue
+++ b/ee/app/assets/javascripts/ai/duo_agentic_chat/components/app.vue
@@ -11,6 +11,7 @@ import { duoChatGlobalState } from '~/super_sidebar/constants';
 import { clearDuoChatCommands, setAgenticMode } from 'ee/ai/utils';
 import { parseGid, convertToGraphQLId } from '~/graphql_shared/utils';
 import { TYPENAME_AI_DUO_WORKFLOW } from '~/graphql_shared/constants';
+import DuoChatLoggingAlert from 'ee/ai/components/duo_chat_logging_alert.vue';
 import {
   GENIE_CHAT_RESET_MESSAGE,
   GENIE_CHAT_CLEAR_MESSAGE,
@@ -42,6 +43,7 @@ export default {
     AgenticDuoChat,
     GlToggle,
     ModelSelectDropdown,
+    DuoChatLoggingAlert,
   },
   provide() {
     return {
@@ -66,7 +68,7 @@ export default {
       default: null,
     },
     metadata: {
-      type: String,
+      type: Object,
       required: false,
       default: null,
     },
@@ -288,7 +290,7 @@ export default {
           workflowID: this.workflowId,
           clientVersion: DUO_WORKFLOW_CLIENT_VERSION,
           workflowDefinition: DUO_WORKFLOW_CHAT_DEFINITION,
-          workflowMetadata: this.metadata,
+          workflowMetadata: this.metadata && JSON.stringify(this.metadata),
           goal,
           approval,
         },
@@ -516,7 +518,11 @@ export default {
         @thread-selected="onThreadSelected"
         @back-to-list="onBackToList"
         @delete-thread="onDeleteThread"
-        ><template #footer-controls>
+      >
+        <template #subheader>
+          <duo-chat-logging-alert :metadata="metadata" />
+        </template>
+        <template #footer-controls>
           <div :class="{ 'gl-flex gl-justify-between': userModelSelectionEnabled }">
             <div class="gl-flex gl-px-4 gl-pb-2 gl-pt-5">
               <gl-toggle
diff --git a/ee/app/assets/javascripts/ai/duo_agentic_chat/index.js b/ee/app/assets/javascripts/ai/duo_agentic_chat/index.js
index b2e5ac783c5b22..34808ff8f0898e 100644
--- a/ee/app/assets/javascripts/ai/duo_agentic_chat/index.js
+++ b/ee/app/assets/javascripts/ai/duo_agentic_chat/index.js
@@ -1,8 +1,10 @@
 import Vue from 'vue';
 import VueApollo from 'vue-apollo';
+import * as Sentry from '~/sentry/sentry_browser_wrapper';
 import createDefaultClient from '~/lib/graphql';
 import { parseBoolean } from '~/lib/utils/common_utils';
 import { activeWorkItemIds } from '~/work_items/utils';
+import { convertObjectPropsToCamelCase } from '~/lib/utils/common_utils';
 import store from '../tanuki_bot/store';
 import DuoAgenticChatApp from './components/app.vue';
 
@@ -14,6 +16,7 @@ const apolloProvider = new VueApollo({
 
 export const initDuoAgenticChat = () => {
   const el = document.getElementById('js-duo-agentic-chat-app');
+  let notConvertedMetadata = {};
 
   if (!el) {
     return false;
@@ -21,6 +24,18 @@ export const initDuoAgenticChat = () => {
 
   const { projectId, namespaceId, resourceId, metadata, userModelSelectionEnabled } = el.dataset;
 
+  try {
+    notConvertedMetadata = JSON.parse(el.dataset.metadata);
+  } catch (error) {
+    Sentry.captureException(error);
+    notConvertedMetadata = {
+      extended_logging: false,
+      is_team_member: false,
+    };
+  }
+
+  const metadata = convertObjectPropsToCamelCase(notConvertedMetadata);
+
   return new Vue({
     el,
     store: store(),
diff --git a/ee/app/assets/javascripts/ai/tanuki_bot/components/app.vue b/ee/app/assets/javascripts/ai/tanuki_bot/components/app.vue
index 85450d6f223e0c..392f611abc15e7 100644
--- a/ee/app/assets/javascripts/ai/tanuki_bot/components/app.vue
+++ b/ee/app/assets/javascripts/ai/tanuki_bot/components/app.vue
@@ -12,6 +12,7 @@ import { getCookie } from '~/lib/utils/common_utils';
 import { duoChatGlobalState } from '~/super_sidebar/constants';
 import { clearDuoChatCommands, generateEventLabelFromText, setAgenticMode } from 'ee/ai/utils';
 import DuoChatCallout from 'ee/ai/components/global_callout/duo_chat_callout.vue';
+import DuoChatLoggingAlert from 'ee/ai/components/duo_chat_logging_alert.vue';
 import getAiMessages from 'ee/ai/graphql/get_ai_messages.query.graphql';
 import getAiConversationThreads from 'ee/ai/graphql/get_ai_conversation_threads.query.graphql';
 import getAiMessagesWithThread from 'ee/ai/graphql/get_ai_messages_with_thread.query.graphql';
@@ -59,6 +60,7 @@ export default {
     DuoChatCallout,
     TanukiBotSubscriptions,
     GlToggle,
+    DuoChatLoggingAlert,
   },
   mixins: [InternalEvents.mixin(), glFeatureFlagsMixin()],
   provide() {
@@ -97,6 +99,11 @@ export default {
       required: false,
       default: false,
     },
+    metadata: {
+      type: Object,
+      required: false,
+      default: null,
+    },
   },
   apollo: {
     // eslint-disable-next-line @gitlab/vue-no-undef-apollo-properties
@@ -539,7 +546,11 @@ export default {
         @chat-hidden="onChatClose"
         @track-feedback="onTrackFeedback"
         @chat-resize="onChatResize"
-        ><template v-if="agenticAvailable" #footer-controls>
+      >
+        <template #subheader>
+          <duo-chat-logging-alert :metadata="metadata" />
+        </template>
+        <template v-if="agenticAvailable" #footer-controls>
           <div class="gl-flex gl-px-4 gl-pb-2 gl-pt-5">
             <gl-toggle
               v-model="duoAgenticModePreference"
diff --git a/ee/app/assets/javascripts/ai/tanuki_bot/index.js b/ee/app/assets/javascripts/ai/tanuki_bot/index.js
index f2bd4f6b141053..11b6fd038972fd 100644
--- a/ee/app/assets/javascripts/ai/tanuki_bot/index.js
+++ b/ee/app/assets/javascripts/ai/tanuki_bot/index.js
@@ -1,8 +1,9 @@
 import Vue from 'vue';
 import VueApollo from 'vue-apollo';
+import * as Sentry from '~/sentry/sentry_browser_wrapper';
 import createDefaultClient from '~/lib/graphql';
 import { duoChatGlobalState } from '~/super_sidebar/constants';
-import { getCookie } from '~/lib/utils/common_utils';
+import { getCookie, convertObjectPropsToCamelCase } from '~/lib/utils/common_utils';
 import { DUO_AGENTIC_MODE_COOKIE } from 'ee/ai/tanuki_bot/constants';
 import TanukiBotChatApp from './components/app.vue';
 import store from './store';
@@ -15,6 +16,7 @@ const apolloProvider = new VueApollo({
 
 export const initTanukiBotChatDrawer = () => {
   const el = document.getElementById('js-tanuki-bot-chat-app');
+  let notConvertedMetadata = {};
 
   if (!el) {
     return false;
@@ -23,6 +25,18 @@ export const initTanukiBotChatDrawer = () => {
   const { userId, resourceId, projectId, chatTitle, rootNamespaceId, agenticAvailable } =
     el.dataset;
 
+  try {
+    notConvertedMetadata = JSON.parse(el.dataset.metadata);
+  } catch (error) {
+    Sentry.captureException(error);
+    notConvertedMetadata = {
+      extended_logging: false,
+      is_team_member: false,
+    };
+  }
+
+  const metadata = convertObjectPropsToCamelCase(notConvertedMetadata);
+
   const toggleEls = document.querySelectorAll('.js-tanuki-bot-chat-toggle');
   if (toggleEls.length) {
     toggleEls.forEach((toggleEl) => {
@@ -51,6 +65,7 @@ export const initTanukiBotChatDrawer = () => {
           chatTitle,
           rootNamespaceId,
           agenticAvailable: JSON.parse(agenticAvailable),
+          metadata,
         },
       });
     },
diff --git a/ee/app/views/layouts/_tanuki_bot_chat.html.haml b/ee/app/views/layouts/_tanuki_bot_chat.html.haml
index 32ef0c59d85186..728466a2da2e45 100644
--- a/ee/app/views/layouts/_tanuki_bot_chat.html.haml
+++ b/ee/app/views/layouts/_tanuki_bot_chat.html.haml
@@ -4,15 +4,23 @@
 - root_namespace_id = Gitlab::Llm::TanukiBot.root_namespace_id
 - chat_title = ::Ai::AmazonQ.enabled? ? s_('GitLab Duo Chat with Amazon Q') : s_('GitLab Duo Chat')
 - is_agentic_available = Gitlab::Llm::TanukiBot.agentic_mode_available?(user: current_user, project: @project, group: @group)
+<<<<<<< HEAD
 - user_model_selection_enabled = Gitlab::Llm::TanukiBot.user_model_selection_enabled?(user: current_user)
+=======
+- metadata = Gitlab::DuoWorkflow::Client.metadata(current_user).to_json
+>>>>>>> 216c48e35648 (feat: Add alert to inform gitlab team members about logging)
 
 - if is_agentic_available
   #js-duo-agentic-chat-app{ data: {
     project_id: @project&.to_global_id,
     namespace_id: @group&.to_global_id,
     resource_id: resource_id,
+<<<<<<< HEAD
     metadata: Gitlab::DuoWorkflow::Client.metadata(current_user).to_json,
     user_model_selection_enabled: user_model_selection_enabled.to_s } }
+=======
+    metadata: metadata } }
+>>>>>>> 216c48e35648 (feat: Add alert to inform gitlab team members about logging)
 
 #js-tanuki-bot-chat-app{ data: {
   user_id: current_user.to_global_id,
@@ -20,4 +28,5 @@
   project_id: project_id,
   root_namespace_id: root_namespace_id,
   chat_title: chat_title,
-  agentic_available: is_agentic_available.to_s } }
+  agentic_available: is_agentic_available.to_s,
+  metadata: metadata } }
diff --git a/ee/spec/frontend/ai/components/duo_chat_logging_alert_spec.js b/ee/spec/frontend/ai/components/duo_chat_logging_alert_spec.js
new file mode 100644
index 00000000000000..3d6d2f08e46bed
--- /dev/null
+++ b/ee/spec/frontend/ai/components/duo_chat_logging_alert_spec.js
@@ -0,0 +1,230 @@
+import { nextTick } from 'vue';
+import { GlAlert, GlSprintf } from '@gitlab/ui';
+import { shallowMountExtended } from 'helpers/vue_test_utils_helper';
+import { getCookie, setCookie } from '~/lib/utils/common_utils';
+import { DUO_AGENTIC_CHAT_LOGGING_ALERT } from 'ee/ai/constants';
+import DuoChatLoggingAlert from 'ee/ai/components/duo_chat_logging_alert.vue';
+
+jest.mock('~/lib/utils/common_utils', () => ({
+  getCookie: jest.fn(),
+  setCookie: jest.fn(),
+}));
+
+describe('DuoChatLoggingAlert', () => {
+  let wrapper;
+
+  const createComponent = (props = { metadata: { isTeamMember: true, extendedLogging: true } }) => {
+    wrapper = shallowMountExtended(DuoChatLoggingAlert, {
+      propsData: {
+        ...props,
+      },
+    });
+  };
+
+  const findAlert = () => wrapper.findComponent(GlAlert);
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    getCookie.mockReturnValue(null);
+  });
+
+  describe('Alert visibility', () => {
+    it('renders alert when user is team member, extendedLogging is true, and alert is not dismissed', async () => {
+      createComponent();
+      await nextTick();
+
+      expect(findAlert().exists()).toBe(true);
+    });
+
+    it('does not render alert when user is not a team member', () => {
+      createComponent({
+        metadata: { isTeamMember: false, extendedLogging: true },
+      });
+
+      expect(findAlert().exists()).toBe(false);
+    });
+
+    it('does not render alert when extendedLogging is false', () => {
+      createComponent({
+        metadata: { isTeamMember: true, extendedLogging: false },
+      });
+
+      expect(findAlert().exists()).toBe(false);
+    });
+
+    it('does not render alert when extendedLogging is undefined', () => {
+      createComponent({
+        metadata: { isTeamMember: true },
+      });
+
+      expect(findAlert().exists()).toBe(false);
+    });
+
+    it('does not render alert when user is team member but alert was dismissed', () => {
+      getCookie.mockReturnValue('true');
+      createComponent();
+
+      expect(findAlert().exists()).toBe(false);
+    });
+
+    it('does not render alert when metadata is undefined', () => {
+      createComponent({ metadata: undefined });
+
+      expect(findAlert().exists()).toBe(false);
+    });
+
+    it('does not render alert when metadata is null', () => {
+      createComponent({ metadata: null });
+
+      expect(findAlert().exists()).toBe(false);
+    });
+
+    it('does not render alert when metadata.is_team_member is undefined', () => {
+      createComponent({
+        metadata: { extendedLogging: true },
+      });
+
+      expect(findAlert().exists()).toBe(false);
+    });
+  });
+
+  describe('Alert properties', () => {
+    beforeEach(() => {
+      createComponent();
+    });
+
+    it('renders alert with correct props', () => {
+      const alert = findAlert();
+
+      expect(alert.props()).toMatchObject({
+        dismissible: true,
+        variant: 'warning',
+        title: 'GitLab Team Member Notice: Chat Logging Active',
+        primaryButtonLink:
+          'https://internal.gitlab.com/handbook/product/ai-strategy/duo-logging/#logging-duo-chat-usage-by-gitlab-team-members-without-logging-their-names-or-user-id',
+        primaryButtonText: 'Learn more',
+      });
+    });
+
+    it('renders alert with correct test attributes', () => {
+      const alert = findAlert();
+
+      expect(alert.attributes('role')).toBe('alert');
+      expect(alert.attributes('data-testid')).toBe('duo-alert-logging');
+    });
+
+    it('renders alert content with all list items', () => {
+      const alertText = findAlert().html();
+
+      expect(alertText).toContain("What's logged:");
+      expect(alertText).toContain('Which interfaces are affected:');
+      expect(alertText).toContain('Privacy safeguards:');
+      expect(alertText).toContain('Purpose:');
+      expect(alertText).toContain('Customers are not affected:');
+    });
+
+    it('renders all GlSprintf components', () => {
+      const sprintfComponents = wrapper.findAllComponents(GlSprintf);
+      expect(sprintfComponents).toHaveLength(5);
+    });
+  });
+
+  describe('Cookie initialization on mount', () => {
+    it('reads cookie and sets isDismissed to true when cookie is "true"', () => {
+      getCookie.mockReturnValue('true');
+      createComponent();
+
+      expect(getCookie).toHaveBeenCalledWith(DUO_AGENTIC_CHAT_LOGGING_ALERT);
+      expect(wrapper.vm.isDismissed).toBe(true);
+      expect(findAlert().exists()).toBe(false);
+    });
+
+    it('reads cookie and sets isDismissed to false when cookie is null', async () => {
+      createComponent();
+      await nextTick();
+
+      expect(getCookie).toHaveBeenCalledWith(DUO_AGENTIC_CHAT_LOGGING_ALERT);
+      expect(wrapper.vm.isDismissed).toBe(false);
+      expect(findAlert().exists()).toBe(true);
+    });
+
+    it('reads cookie and sets isDismissed to false when cookie is not "true"', async () => {
+      getCookie.mockReturnValue('false');
+      createComponent();
+      await nextTick();
+
+      expect(getCookie).toHaveBeenCalledWith(DUO_AGENTIC_CHAT_LOGGING_ALERT);
+      expect(wrapper.vm.isDismissed).toBe(false);
+      expect(findAlert().exists()).toBe(true);
+    });
+  });
+
+  describe('Alert dismissal', () => {
+    beforeEach(() => {
+      createComponent();
+    });
+
+    it('sets cookie and updates isDismissed when alert is dismissed', async () => {
+      const alert = findAlert();
+      expect(alert.exists()).toBe(true);
+
+      alert.vm.$emit('dismiss');
+      await nextTick();
+
+      expect(setCookie).toHaveBeenCalledWith(DUO_AGENTIC_CHAT_LOGGING_ALERT, true);
+      expect(wrapper.vm.isDismissed).toBe(true);
+      expect(findAlert().exists()).toBe(false);
+    });
+
+    it('calls onDismiss method when dismiss event is emitted', async () => {
+      const onDismissSpy = jest.spyOn(DuoChatLoggingAlert.methods, 'onDismiss');
+      createComponent();
+      await nextTick();
+      findAlert().vm.$emit('dismiss');
+      await nextTick();
+
+      expect(onDismissSpy).toHaveBeenCalled();
+
+      onDismissSpy.mockRestore();
+    });
+  });
+
+  describe('hasAlert computed property', () => {
+    it.each`
+      isTeamMember | extendedLogging | isDismissed | expected | scenario
+      ${true}      | ${true}         | ${false}    | ${true}  | ${'shows when all conditions are met'}
+      ${false}     | ${true}         | ${false}    | ${false} | ${'hides when not team member'}
+      ${true}      | ${false}        | ${false}    | ${false} | ${'hides when extended_logging is false'}
+      ${true}      | ${undefined}    | ${false}    | ${false} | ${'hides when extended_logging is undefined'}
+      ${true}      | ${true}         | ${true}     | ${false} | ${'hides when dismissed'}
+      ${undefined} | ${true}         | ${false}    | ${false} | ${'hides when is_team_member is undefined'}
+    `('$scenario', async ({ isTeamMember, extendedLogging, isDismissed, expected }) => {
+      getCookie.mockReturnValue(isDismissed ? 'true' : null);
+      createComponent({
+        metadata: {
+          isTeamMember,
+          extendedLogging,
+        },
+      });
+      await nextTick();
+
+      expect(findAlert().exists()).toBe(expected);
+    });
+  });
+
+  describe('Props validation', () => {
+    it('handles null metadata prop', () => {
+      createComponent({ metadata: null });
+
+      expect(() => wrapper.vm).not.toThrow();
+      expect(findAlert().exists()).toBe(false);
+    });
+
+    it('handles undefined metadata prop', () => {
+      createComponent({ metadata: undefined });
+
+      expect(() => wrapper.vm).not.toThrow();
+      expect(findAlert().exists()).toBe(false);
+    });
+  });
+});
diff --git a/ee/spec/frontend/ai/duo_agentic_chat/components/app_spec.js b/ee/spec/frontend/ai/duo_agentic_chat/components/app_spec.js
index 97df7cb5610736..5a123f90cbc489 100644
--- a/ee/spec/frontend/ai/duo_agentic_chat/components/app_spec.js
+++ b/ee/spec/frontend/ai/duo_agentic_chat/components/app_spec.js
@@ -13,6 +13,7 @@ import { duoChatGlobalState } from '~/super_sidebar/constants';
 import getUserWorkflows from 'ee/ai/graphql/get_user_workflow.query.graphql';
 import getAiChatContextPresets from 'ee/ai/graphql/get_ai_chat_context_presets.query.graphql';
 import DuoAgenticChatApp from 'ee/ai/duo_agentic_chat/components/app.vue';
+import DuoChatLoggingAlert from 'ee/ai/components/duo_chat_logging_alert.vue';
 import { ApolloUtils } from 'ee/ai/duo_agentic_chat/utils/apollo_utils';
 import { WorkflowUtils } from 'ee/ai/duo_agentic_chat/utils/workflow_utils';
 import ModelSelectDropdown from 'ee/ai/shared/feature_settings/model_select_dropdown.vue';
@@ -75,7 +76,11 @@ const MOCK_USER_MESSAGE = {
   role: 'user',
   requestId: `${MOCK_WORKFLOW_ID}-0`,
 };
-const MOCK_AI_RESOURCE_DATA = JSON.stringify({ type: 'issue', id: 789, title: 'Test Issue' });
+const MOCK_AI_RESOURCE_DATA = JSON.stringify({
+  type: 'issue',
+  id: 789,
+  title: 'Test Issue',
+});
 const MOCK_CONTEXT_PRESETS_RESPONSE = {
   data: {
     aiChatContextPresets: {
@@ -153,6 +158,7 @@ Vue.use(VueApollo);
 
 jest.mock('~/lib/utils/common_utils', () => ({
   getCookie: jest.fn(),
+  setCookie: jest.fn(),
 }));
 
 jest.mock('~/lib/utils/local_storage', () => ({
@@ -185,6 +191,8 @@ describe('Duo Agentic Chat', () => {
   const contextPresetsQueryHandlerMock = jest.fn().mockResolvedValue(MOCK_CONTEXT_PRESETS_RESPONSE);
 
   const findDuoChat = () => wrapper.findComponent(AgenticDuoChat);
+  const findLoggingAlert = () => wrapper.findComponent(DuoChatLoggingAlert);
+  const findGlToggle = () => wrapper.findComponent(GlToggle);
   const getLastSocketCall = () => {
     const { calls } = createWebSocket.mock;
     if (calls.length === 0) {
@@ -194,11 +202,13 @@ describe('Duo Agentic Chat', () => {
     return socketCallbacks;
   };
 
-  const createComponent = ({
-    initialState = {},
-    propsData = { projectId: MOCK_PROJECT_ID, resourceId: MOCK_RESOURCE_ID },
-    data = {},
-  } = {}) => {
+  const defaultPropsData = {
+    projectId: MOCK_PROJECT_ID,
+    resourceId: MOCK_RESOURCE_ID,
+    metadata: { is_team_member: true, extended_logging: true },
+  };
+
+  const createComponent = ({ initialState = {}, propsData = {} } = {}) => {
     const store = new Vuex.Store({
       actions: actionSpies,
       state: {
@@ -220,9 +230,9 @@ describe('Duo Agentic Chat', () => {
     wrapper = shallowMountExtended(DuoAgenticChatApp, {
       store,
       apolloProvider,
-      propsData,
-      data() {
-        return data;
+      propsData: {
+        ...defaultPropsData,
+        ...propsData,
       },
     });
 
@@ -234,6 +244,9 @@ describe('Duo Agentic Chat', () => {
   beforeEach(() => {
     jest.clearAllMocks();
     mockRefetch.mockClear();
+    mockSocketManager.connect.mockClear();
+    contextPresetsQueryHandlerMock.mockClear();
+    userWorkflowsQueryHandlerMock.mockClear();
     MOCK_UTILS_SETUP();
   });
 
@@ -244,6 +257,8 @@ describe('Duo Agentic Chat', () => {
 
   afterEach(() => {
     duoChatGlobalState.isAgenticChatShown = false;
+    contextPresetsQueryHandlerMock.mockResolvedValue(MOCK_CONTEXT_PRESETS_RESPONSE);
+    userWorkflowsQueryHandlerMock.mockResolvedValue(MOCK_USER_WORKFLOWS_RESPONSE);
   });
 
   describe('rendering', () => {
@@ -323,6 +338,35 @@ describe('Duo Agentic Chat', () => {
     });
   });
 
+  describe('DuoChatLoggingAlert Integration', () => {
+    beforeEach(() => {
+      duoChatGlobalState.isAgenticChatShown = true;
+    });
+
+    it('renders DuoChatLoggingAlert with correct props', () => {
+      const metadata = { is_team_member: true, extended_logging: true };
+      createComponent({ propsData: { metadata } });
+
+      expect(findLoggingAlert().exists()).toBe(true);
+      expect(findLoggingAlert().props('metadata')).toEqual(metadata);
+    });
+
+    it('renders DuoChatLoggingAlert in the subheader slot', () => {
+      createComponent();
+
+      expect(findDuoChat().vm.$slots.subheader).toBeDefined();
+      expect(findLoggingAlert().exists()).toBe(true);
+    });
+
+    it('does not render DuoChatLoggingAlert when Duo Chat is not shown', () => {
+      duoChatGlobalState.isAgenticChatShown = false;
+      createComponent();
+
+      expect(findDuoChat().exists()).toBe(false);
+      expect(findLoggingAlert().exists()).toBe(false);
+    });
+  });
+
   describe('events handling', () => {
     beforeEach(() => {
       createComponent();
@@ -385,7 +429,10 @@ describe('Duo Agentic Chat', () => {
 
       it('creates a new workflow when sending a prompt for the first time with namespaceId', async () => {
         createComponent({
-          propsData: { namespaceId: MOCK_NAMESPACE_ID, resourceId: MOCK_RESOURCE_ID },
+          propsData: {
+            projectId: null,
+            namespaceId: MOCK_NAMESPACE_ID,
+          },
         });
         duoChatGlobalState.isAgenticChatShown = true;
 
@@ -438,7 +485,12 @@ describe('Duo Agentic Chat', () => {
 
       it('creates a new workflow when sending a prompt for the first time without projectId or namespaceId', async () => {
         createComponent({
-          propsData: { resourceId: MOCK_RESOURCE_ID },
+          propsData: {
+            projectId: undefined,
+            namespaceId: undefined,
+            resourceId: MOCK_RESOURCE_ID,
+            metadata: undefined,
+          },
         });
         duoChatGlobalState.isAgenticChatShown = true;
 
@@ -474,6 +526,16 @@ describe('Duo Agentic Chat', () => {
       });
 
       it('sends the correct start request to WebSocket when connected', async () => {
+        createComponent({
+          propsData: {
+            projectId: undefined,
+            namespaceId: undefined,
+            resourceId: MOCK_RESOURCE_ID,
+            metadata: undefined,
+          },
+        });
+
+        await waitForPromises(); // Wait for Apollo queries to complete
         findDuoChat().vm.$emit('send-chat-prompt', MOCK_USER_MESSAGE.content);
         await waitForPromises();
 
@@ -546,6 +608,292 @@ describe('Duo Agentic Chat', () => {
         );
         expect(findDuoChat().props('activeThreadId')).toBe('Test goal for activeThread');
       });
+      describe('startWorkflow request structure validation', () => {
+        describe('required fields validation', () => {
+          beforeEach(async () => {
+            createComponent();
+            duoChatGlobalState.isAgenticChatShown = true;
+            await waitForPromises();
+          });
+
+          afterEach(() => {
+            mockSocketManager.connect.mockClear();
+          });
+
+          it('sends all required fields according to protobuf schema', async () => {
+            findDuoChat().vm.$emit('send-chat-prompt', 'test question');
+            await waitForPromises();
+
+            // for details see contract: https://gitlab.com/gitlab-org/modelops/applied-ml/code-suggestions/ai-assist/-/blob/9716e956e1e643adf64b361d9334ddfc182e2279/contract/contract.proto#L21
+            expect(mockSocketManager.connect).toHaveBeenCalledWith(
+              expect.objectContaining({
+                startRequest: expect.objectContaining({
+                  clientVersion: expect.any(String),
+                  workflowID: expect.any(String),
+                  workflowDefinition: expect.any(String),
+                  goal: expect.any(String),
+                  workflowMetadata: expect.any(String),
+                  approval: expect.any(Object),
+                }),
+              }),
+            );
+          });
+
+          it('validates field types match protobuf schema', async () => {
+            findDuoChat().vm.$emit('send-chat-prompt', 'test question');
+            await waitForPromises();
+
+            const callArg = mockSocketManager.connect.mock.calls[0][0];
+            const { startRequest } = callArg;
+
+            expect(typeof startRequest.clientVersion).toBe('string');
+            expect(typeof startRequest.workflowID).toBe('string');
+            expect(typeof startRequest.workflowDefinition).toBe('string');
+            expect(typeof startRequest.goal).toBe('string');
+            expect(typeof startRequest.workflowMetadata).toBe('string');
+            expect(typeof startRequest.approval).toBe('object');
+
+            if (startRequest.additionalContext) {
+              expect(Array.isArray(startRequest.additionalContext)).toBe(true);
+            }
+          });
+        });
+
+        describe('metadata field handling', () => {
+          beforeEach(async () => {
+            createComponent();
+            duoChatGlobalState.isAgenticChatShown = true;
+            await waitForPromises();
+            mockSocketManager.connect.mockClear(); // Clear calls from the default component
+          });
+
+          afterEach(() => {
+            mockSocketManager.connect.mockClear();
+            if (wrapper) {
+              wrapper.destroy();
+              wrapper = null;
+            }
+          });
+
+          it('stringifies metadata object correctly', async () => {
+            const metadata = {
+              is_team_member: true,
+              extended_logging: false,
+            };
+
+            createComponent({
+              propsData: {
+                projectId: MOCK_PROJECT_ID,
+                resourceId: MOCK_RESOURCE_ID,
+                metadata,
+              },
+            });
+            duoChatGlobalState.isAgenticChatShown = true;
+            await waitForPromises();
+
+            findDuoChat().vm.$emit('send-chat-prompt', 'test question');
+            await waitForPromises();
+
+            const callArg = mockSocketManager.connect.mock.calls[0][0];
+            expect(callArg.startRequest.workflowMetadata).toBe(JSON.stringify(metadata));
+          });
+
+          it('handles null metadata', async () => {
+            createComponent({
+              propsData: {
+                projectId: MOCK_PROJECT_ID,
+                resourceId: MOCK_RESOURCE_ID,
+                metadata: null,
+              },
+            });
+            duoChatGlobalState.isAgenticChatShown = true;
+            await waitForPromises();
+
+            findDuoChat().vm.$emit('send-chat-prompt', 'test question');
+            await waitForPromises();
+
+            const callArg = mockSocketManager.connect.mock.calls[0][0];
+            expect(callArg.startRequest.workflowMetadata).toBe(null);
+          });
+
+          it('handles undefined metadata', async () => {
+            createComponent({
+              propsData: {
+                projectId: MOCK_PROJECT_ID,
+                resourceId: MOCK_RESOURCE_ID,
+                metadata: undefined,
+              },
+            });
+
+            duoChatGlobalState.isAgenticChatShown = true;
+            await waitForPromises();
+
+            findDuoChat().vm.$emit('send-chat-prompt', 'test question');
+            await waitForPromises();
+
+            const callArg = mockSocketManager.connect.mock.calls[0][0];
+            expect(callArg.startRequest.workflowMetadata).toBe(null);
+          });
+
+          it('handles empty object metadata', async () => {
+            createComponent({
+              propsData: {
+                projectId: MOCK_PROJECT_ID,
+                resourceId: MOCK_RESOURCE_ID,
+                metadata: {},
+              },
+            });
+            duoChatGlobalState.isAgenticChatShown = true;
+            await waitForPromises();
+
+            findDuoChat().vm.$emit('send-chat-prompt', 'test question');
+            await waitForPromises();
+
+            const callArg = mockSocketManager.connect.mock.calls[0][0];
+            expect(callArg.startRequest.workflowMetadata).toBe('{}');
+          });
+        });
+
+        describe('optional fields handling', () => {
+          afterEach(() => {
+            mockSocketManager.connect.mockClear();
+          });
+
+          it('includes additionalContext when context presets are available', async () => {
+            createComponent();
+            duoChatGlobalState.isAgenticChatShown = true;
+            await waitForPromises();
+
+            findDuoChat().vm.$emit('send-chat-prompt', 'test question');
+            await waitForPromises();
+
+            const callArg = mockSocketManager.connect.mock.calls[0][0];
+            expect(callArg.startRequest.additionalContext).toEqual([
+              {
+                content: MOCK_AI_RESOURCE_DATA,
+                category: DUO_WORKFLOW_ADDITIONAL_CONTEXT_REPOSITORY,
+                metadata: '{}',
+              },
+            ]);
+          });
+
+          it('does not include additionalContext field when no context presets', async () => {
+            contextPresetsQueryHandlerMock.mockResolvedValueOnce({
+              data: { aiChatContextPresets: { questions: [], aiResourceData: null } },
+            });
+
+            createComponent({
+              propsData: {
+                projectId: MOCK_PROJECT_ID,
+                resourceId: MOCK_RESOURCE_ID,
+                metadata: { is_team_member: true, extended_logging: true },
+              },
+            });
+
+            await nextTick();
+
+            duoChatGlobalState.isAgenticChatShown = true;
+            await waitForPromises();
+
+            findDuoChat().vm.$emit('send-chat-prompt', 'test question');
+            await waitForPromises();
+
+            const callArg = mockSocketManager.connect.mock.calls.pop()[0];
+            expect(callArg.startRequest.additionalContext).toBeUndefined();
+          });
+
+          it('sends approval object structure correctly for tool approval', async () => {
+            createComponent();
+            duoChatGlobalState.isAgenticChatShown = true;
+            await waitForPromises();
+
+            wrapper.vm.workflowId = '456';
+            findDuoChat().vm.$emit('approve-tool');
+            await nextTick();
+
+            const callArg = mockSocketManager.connect.mock.calls.pop()[0];
+
+            expect(callArg.startRequest.approval).toEqual({ approval: {} });
+            expect(callArg.startRequest.goal).toBe('');
+          });
+
+          it('sends rejection structure correctly for tool denial', async () => {
+            createComponent();
+            duoChatGlobalState.isAgenticChatShown = true;
+            await waitForPromises();
+
+            wrapper.vm.workflowId = '456';
+            const denyMessage = 'Not approved';
+            findDuoChat().vm.$emit('deny-tool', denyMessage);
+            await nextTick();
+
+            const callArg = mockSocketManager.connect.mock.calls.pop()[0];
+            expect(callArg.startRequest.approval).toEqual({
+              approval: undefined,
+              rejection: { message: denyMessage },
+            });
+            expect(callArg.startRequest.goal).toBe('');
+          });
+        });
+
+        describe('constant values validation', () => {
+          beforeEach(async () => {
+            createComponent();
+            duoChatGlobalState.isAgenticChatShown = true;
+            await waitForPromises();
+          });
+
+          afterEach(() => {
+            mockSocketManager.connect.mockClear();
+          });
+
+          it('uses correct constant values for clientVersion and workflowDefinition', async () => {
+            findDuoChat().vm.$emit('send-chat-prompt', 'test question');
+            await waitForPromises();
+
+            const callArg = mockSocketManager.connect.mock.calls[0][0];
+            expect(callArg.startRequest.clientVersion).toBe('1.0');
+            expect(callArg.startRequest.workflowDefinition).toBe('chat');
+          });
+        });
+
+        describe('protobuf schema compliance', () => {
+          beforeEach(async () => {
+            createComponent();
+            duoChatGlobalState.isAgenticChatShown = true;
+            await waitForPromises();
+          });
+
+          afterEach(() => {
+            mockSocketManager.connect.mockClear();
+          });
+
+          it('does not include fields not defined in protobuf schema', async () => {
+            findDuoChat().vm.$emit('send-chat-prompt', 'test question');
+            await waitForPromises();
+
+            const callArg = mockSocketManager.connect.mock.calls[0][0];
+            const allowedFields = [
+              'clientVersion',
+              'workflowID',
+              'workflowDefinition',
+              'goal',
+              'workflowMetadata',
+              'clientCapabilities',
+              'mcpTools',
+              'additionalContext',
+              'approval',
+              'flowConfig',
+              'flowConfigSchemaVersion',
+            ];
+            const actualFields = Object.keys(callArg.startRequest);
+
+            actualFields.forEach((field) => {
+              expect(allowedFields).toContain(field);
+            });
+          });
+        });
+      });
 
       it('handles tool approval flow', async () => {
         const mockCheckpointData = {
@@ -672,7 +1020,7 @@ describe('Duo Agentic Chat', () => {
             workflowDefinition: 'chat',
             goal: '',
             approval: { approval: {} },
-            workflowMetadata: null,
+            workflowMetadata: JSON.stringify({ is_team_member: true, extended_logging: true }),
             additionalContext: expectedAdditionalContext,
           },
         };
@@ -766,7 +1114,7 @@ describe('Duo Agentic Chat', () => {
               approval: undefined,
               rejection: { message: denyMessage },
             },
-            workflowMetadata: null,
+            workflowMetadata: JSON.stringify({ is_team_member: true, extended_logging: true }),
             additionalContext: expectedAdditionalContext,
           },
         };
@@ -854,7 +1202,7 @@ describe('Duo Agentic Chat', () => {
               approval: undefined,
               rejection: { message: 'I do not approve this action' },
             },
-            workflowMetadata: null,
+            workflowMetadata: JSON.stringify({ is_team_member: true, extended_logging: true }),
             additionalContext: expectedAdditionalContext,
           },
         };
@@ -1149,8 +1497,6 @@ describe('Duo Agentic Chat', () => {
   });
 
   describe('duoAgenticModePreference toggle', () => {
-    const findGlToggle = () => wrapper.findComponent(GlToggle);
-
     beforeEach(() => {
       duoChatGlobalState.isAgenticChatShown = true;
       jest.clearAllMocks();
@@ -1200,7 +1546,9 @@ describe('Duo Agentic Chat', () => {
     describe('@thread-selected', () => {
       it('switches to selected thread and fetches workflow events', async () => {
         const mockThread = { id: MOCK_WORKFLOW_ID };
-        const mockParsedData = { checkpoint: { channel_values: { ui_chat_log: [] } } };
+        const mockParsedData = {
+          checkpoint: { channel_values: { ui_chat_log: [] } },
+        };
 
         WorkflowUtils.parseWorkflowData.mockReturnValue(mockParsedData);
         WorkflowUtils.transformChatMessages.mockReturnValue(MOCK_TRANSFORMED_MESSAGES);
@@ -1273,15 +1621,13 @@ describe('Duo Agentic Chat', () => {
   });
 
   describe('Agentic Mode Toggle', () => {
-    const findGlToggle = () => wrapper.findComponent(GlToggle);
-
     beforeEach(() => {
       duoChatGlobalState.isAgenticChatShown = true;
       getCookie.mockReturnValue('false');
       createComponent();
     });
 
-    it('renders the GlToggle component in subheader', () => {
+    it('renders the GlToggle component in footer-controls', () => {
       expect(findGlToggle().exists()).toBe(true);
     });
 
diff --git a/ee/spec/frontend/ai/tanuki_bot/components/app_spec.js b/ee/spec/frontend/ai/tanuki_bot/components/app_spec.js
index 3bbcb01df7fe4b..df722676248877 100644
--- a/ee/spec/frontend/ai/tanuki_bot/components/app_spec.js
+++ b/ee/spec/frontend/ai/tanuki_bot/components/app_spec.js
@@ -8,6 +8,7 @@ import { GlToggle } from '@gitlab/ui';
 import { sendDuoChatCommand, setAgenticMode } from 'ee/ai/utils';
 import TanukiBotChatApp from 'ee/ai/tanuki_bot/components/app.vue';
 import DuoChatCallout from 'ee/ai/components/global_callout/duo_chat_callout.vue';
+import DuoChatLoggingAlert from 'ee/ai/components/duo_chat_logging_alert.vue';
 import TanukiBotSubscriptions from 'ee/ai/tanuki_bot/components/tanuki_bot_subscriptions.vue';
 import {
   GENIE_CHAT_RESET_MESSAGE,
@@ -116,6 +117,7 @@ describeSkipVue3(skipReason, () => {
 
   const findCallout = () => wrapper.findComponent(DuoChatCallout);
   const findSubscriptions = () => wrapper.findComponent(TanukiBotSubscriptions);
+  const findLoggingAlert = () => wrapper.findComponent(DuoChatLoggingAlert);
 
   const createComponent = ({
     initialState = {},
@@ -294,6 +296,41 @@ describeSkipVue3(skipReason, () => {
     });
   });
 
+  describe('DuoChatLoggingAlert Integration', () => {
+    beforeEach(() => {
+      duoChatGlobalState.isShown = true;
+    });
+
+    it('renders DuoChatLoggingAlert with correct props', () => {
+      const metadata = { is_team_member: true, extended_logging: true };
+      createComponent({
+        propsData: {
+          userId: MOCK_USER_ID,
+          resourceId: MOCK_RESOURCE_ID,
+          metadata,
+        },
+      });
+
+      expect(findLoggingAlert().exists()).toBe(true);
+      expect(findLoggingAlert().props('metadata')).toEqual(metadata);
+    });
+
+    it('renders DuoChatLoggingAlert in the subheader slot', () => {
+      createComponent();
+
+      expect(findDuoChat().vm.$slots.subheader).toBeDefined();
+      expect(findLoggingAlert().exists()).toBe(true);
+    });
+
+    it('does not render DuoChatLoggingAlert when Duo Chat is not shown', () => {
+      duoChatGlobalState.isShown = false;
+      createComponent();
+
+      expect(findDuoChat().exists()).toBe(false);
+      expect(findLoggingAlert().exists()).toBe(false);
+    });
+  });
+
   describe('contextPresets', () => {
     beforeEach(() => {
       duoChatGlobalState.isShown = true;
@@ -1166,7 +1203,7 @@ describeSkipVue3(skipReason, () => {
 
     it('passes chatTitle prop to DuoChat component', async () => {
       const chatTitle = 'Custom Chat Title';
-      createComponent({ propsData: { chatTitle } });
+      createComponent({ propsData: { userId: MOCK_USER_ID, chatTitle } });
       await nextTick();
       expect(findDuoChat().props('title')).toBe(chatTitle);
     });
@@ -1179,7 +1216,7 @@ describeSkipVue3(skipReason, () => {
 
     it('updates DuoChat title when chatTitle prop changes', async () => {
       const localWrapper = shallowMountExtended(TanukiBotChatApp, {
-        propsData: { chatTitle: 'Initial Title' },
+        propsData: { userId: MOCK_USER_ID, chatTitle: 'Initial Title' },
         store: new Vuex.Store({ actions: actionSpies }),
         apolloProvider: createMockApollo([]),
       });
diff --git a/locale/gitlab.pot b/locale/gitlab.pot
index 4d248ad7ae5bf1..361a58dead3be5 100644
--- a/locale/gitlab.pot
+++ b/locale/gitlab.pot
@@ -646,6 +646,21 @@ msgstr ""
 msgid "%{author} has created a merge request that you can approve."
 msgstr ""
 
+msgid "%{bStart}Customers are not affected:%{bEnd} we never log customer usage of Duo Chat (unless specifically requested by the customer)"
+msgstr ""
+
+msgid "%{bStart}Privacy safeguards:%{bEnd} Your name and user ID are not logged as structured fields"
+msgstr ""
+
+msgid "%{bStart}Purpose:%{bEnd} This data helps us improve Duo Chat and will never be used for performance evaluation. Note: The in-app feedback form states 'GitLab team members cannot see the AI content.' This does not apply for team members' interactions with the chat."
+msgstr ""
+
+msgid "%{bStart}What's logged:%{bEnd} Your questions, contexts (files, issues, MRs, etc.), and Duo's responses"
+msgstr ""
+
+msgid "%{bStart}Which interfaces are affected:%{bEnd} usage of Duo Chat in Web and IDEs as well as Duo Agentic Chat in Web and IDEs"
+msgstr ""
+
 msgid "%{board_target} not found"
 msgstr ""
 
@@ -29948,6 +29963,9 @@ msgstr ""
 msgid "GitLab Team"
 msgstr ""
 
+msgid "GitLab Team Member Notice: Chat Logging Active"
+msgstr ""
+
 msgid "GitLab University"
 msgstr ""
 
-- 
GitLab


From 368aa515b00218e8961b6ceeebfb411a78d29b7b Mon Sep 17 00:00:00 2001
From: Tomas Bulva <tbulva@gitlab.com>
Date: Wed, 27 Aug 2025 16:47:49 +0200
Subject: [PATCH 2/8] feat: Add alert to inform gitlab team members about
 logging

Added alert message to duo chat that
all chats are being logged

This is fix after revert!

Changelog: added
EE: true
---
 ee/app/assets/javascripts/ai/duo_agentic_chat/index.js | 2 +-
 ee/app/views/layouts/_tanuki_bot_chat.html.haml        | 6 ------
 2 files changed, 1 insertion(+), 7 deletions(-)

diff --git a/ee/app/assets/javascripts/ai/duo_agentic_chat/index.js b/ee/app/assets/javascripts/ai/duo_agentic_chat/index.js
index 34808ff8f0898e..a39c9cc2f8b135 100644
--- a/ee/app/assets/javascripts/ai/duo_agentic_chat/index.js
+++ b/ee/app/assets/javascripts/ai/duo_agentic_chat/index.js
@@ -22,7 +22,7 @@ export const initDuoAgenticChat = () => {
     return false;
   }
 
-  const { projectId, namespaceId, resourceId, metadata, userModelSelectionEnabled } = el.dataset;
+  const { projectId, namespaceId, resourceId, userModelSelectionEnabled } = el.dataset;
 
   try {
     notConvertedMetadata = JSON.parse(el.dataset.metadata);
diff --git a/ee/app/views/layouts/_tanuki_bot_chat.html.haml b/ee/app/views/layouts/_tanuki_bot_chat.html.haml
index 728466a2da2e45..ac071327ba5d4c 100644
--- a/ee/app/views/layouts/_tanuki_bot_chat.html.haml
+++ b/ee/app/views/layouts/_tanuki_bot_chat.html.haml
@@ -4,23 +4,17 @@
 - root_namespace_id = Gitlab::Llm::TanukiBot.root_namespace_id
 - chat_title = ::Ai::AmazonQ.enabled? ? s_('GitLab Duo Chat with Amazon Q') : s_('GitLab Duo Chat')
 - is_agentic_available = Gitlab::Llm::TanukiBot.agentic_mode_available?(user: current_user, project: @project, group: @group)
-<<<<<<< HEAD
 - user_model_selection_enabled = Gitlab::Llm::TanukiBot.user_model_selection_enabled?(user: current_user)
-=======
 - metadata = Gitlab::DuoWorkflow::Client.metadata(current_user).to_json
->>>>>>> 216c48e35648 (feat: Add alert to inform gitlab team members about logging)
 
 - if is_agentic_available
   #js-duo-agentic-chat-app{ data: {
     project_id: @project&.to_global_id,
     namespace_id: @group&.to_global_id,
     resource_id: resource_id,
-<<<<<<< HEAD
     metadata: Gitlab::DuoWorkflow::Client.metadata(current_user).to_json,
     user_model_selection_enabled: user_model_selection_enabled.to_s } }
-=======
     metadata: metadata } }
->>>>>>> 216c48e35648 (feat: Add alert to inform gitlab team members about logging)
 
 #js-tanuki-bot-chat-app{ data: {
   user_id: current_user.to_global_id,
-- 
GitLab


From 80acfe92fed3a8e8c5a8cb76f3d92c8ad6afbf3b Mon Sep 17 00:00:00 2001
From: Tomas Bulva <tbulva@gitlab.com>
Date: Thu, 11 Sep 2025 11:56:25 +0200
Subject: [PATCH 3/8] WIP

---
 .../ai/components/duo_chat_logging_alert.vue  | 20 ++-------
 ee/app/assets/javascripts/ai/constants.js     |  2 +
 .../ai/duo_agentic_chat/components/app.vue    | 10 +++--
 .../ai/tanuki_bot/components/app.vue          | 17 ++++---
 ee/app/assets/javascripts/ai/utils.js         |  3 ++
 .../components/duo_chat_logging_alert_spec.js | 10 ++---
 .../duo_agentic_chat/components/app_spec.js   | 28 +++++++++---
 .../ai/tanuki_bot/components/app_spec.js      | 34 +++++++++++---
 ee/spec/frontend/ai/utils_spec.js             | 45 +++++++++++++++++++
 9 files changed, 125 insertions(+), 44 deletions(-)

diff --git a/ee/app/assets/javascripts/ai/components/duo_chat_logging_alert.vue b/ee/app/assets/javascripts/ai/components/duo_chat_logging_alert.vue
index 883252433d05b9..5022e00a956a83 100644
--- a/ee/app/assets/javascripts/ai/components/duo_chat_logging_alert.vue
+++ b/ee/app/assets/javascripts/ai/components/duo_chat_logging_alert.vue
@@ -1,7 +1,7 @@
 <script>
 import { GlAlert, GlSprintf } from '@gitlab/ui';
 import { getCookie, setCookie } from '~/lib/utils/common_utils';
-import { DUO_AGENTIC_CHAT_LOGGING_ALERT } from 'ee/ai/constants';
+import { DUO_AGENTIC_CHAT_LOGGING_ALERT_DISMISSED_COOKIE } from 'ee/ai/constants';
 
 export default {
   name: 'DuoChatLoggingAlert',
@@ -9,33 +9,21 @@ export default {
     GlAlert,
     GlSprintf,
   },
-  props: {
-    metadata: {
-      type: Object,
-      required: false,
-      default: null,
-    },
-  },
   data() {
     return {
       isDismissed: true,
     };
   },
-  computed: {
-    hasAlert() {
-      return this.metadata?.isTeamMember && this.metadata?.extendedLogging && !this.isDismissed;
-    },
-  },
   mounted() {
     this.getLoggingAlertDismissState();
   },
   methods: {
     onDismiss() {
-      setCookie(DUO_AGENTIC_CHAT_LOGGING_ALERT, true);
+      setCookie(DUO_AGENTIC_CHAT_LOGGING_ALERT_DISMISSED_COOKIE, true);
       this.isDismissed = true;
     },
     getLoggingAlertDismissState() {
-      this.isDismissed = getCookie(DUO_AGENTIC_CHAT_LOGGING_ALERT) === 'true';
+      this.isDismissed = getCookie(DUO_AGENTIC_CHAT_LOGGING_ALERT_DISMISSED_COOKIE) === 'true';
     },
   },
 };
@@ -43,7 +31,7 @@ export default {
 
 <template>
   <gl-alert
-    v-if="hasAlert"
+    v-if="!isDismissed"
     :dismissible="true"
     variant="warning"
     class="gl-border-t"
diff --git a/ee/app/assets/javascripts/ai/constants.js b/ee/app/assets/javascripts/ai/constants.js
index 8cf65cd58b6e85..65638302901b02 100644
--- a/ee/app/assets/javascripts/ai/constants.js
+++ b/ee/app/assets/javascripts/ai/constants.js
@@ -57,3 +57,5 @@ export const DUO_CURRENT_WORKFLOW_STORAGE_KEY = 'agenticChat.currentWorkflow';
 
 export const DUO_AGENTIC_CHAT_SELECTED_MODEL_KEY = 'agentic-chat-user-selected-model';
 export const DUO_AGENTIC_CHAT_LOGGING_ALERT = 'duo_agentic_chat_logging_alert';
+export const DUO_AGENTIC_CHAT_LOGGING_ALERT_DISMISSED_COOKIE =
+  'duo_agentic_chat_logging_alert_dismissed';
diff --git a/ee/app/assets/javascripts/ai/duo_agentic_chat/components/app.vue b/ee/app/assets/javascripts/ai/duo_agentic_chat/components/app.vue
index bdb537d828fbef..a6cce5a61f5049 100644
--- a/ee/app/assets/javascripts/ai/duo_agentic_chat/components/app.vue
+++ b/ee/app/assets/javascripts/ai/duo_agentic_chat/components/app.vue
@@ -11,7 +11,6 @@ import { duoChatGlobalState } from '~/super_sidebar/constants';
 import { clearDuoChatCommands, setAgenticMode } from 'ee/ai/utils';
 import { parseGid, convertToGraphQLId } from '~/graphql_shared/utils';
 import { TYPENAME_AI_DUO_WORKFLOW } from '~/graphql_shared/constants';
-import DuoChatLoggingAlert from 'ee/ai/components/duo_chat_logging_alert.vue';
 import {
   GENIE_CHAT_RESET_MESSAGE,
   GENIE_CHAT_CLEAR_MESSAGE,
@@ -43,7 +42,7 @@ export default {
     AgenticDuoChat,
     GlToggle,
     ModelSelectDropdown,
-    DuoChatLoggingAlert,
+    DuoChatLoggingAlert: () => import('ee/ai/components/duo_chat_logging_alert.vue'),
   },
   provide() {
     return {
@@ -171,6 +170,9 @@ export default {
     defaultModel() {
       return this.mockModelSelectionOptions.find((item) => item.value === GITLAB_DEFAULT_MODEL);
     },
+    shouldShowLoggingAlert() {
+      return shouldShowLoggingAlert(this.metadata);
+    },
     predefinedPrompts() {
       return this.contextPresets.questions || [];
     },
@@ -519,8 +521,8 @@ export default {
         @back-to-list="onBackToList"
         @delete-thread="onDeleteThread"
       >
-        <template #subheader>
-          <duo-chat-logging-alert :metadata="metadata" />
+        <template v-if="shouldShowLoggingAlert" #subheader>
+          <duo-chat-logging-alert />
         </template>
         <template #footer-controls>
           <div :class="{ 'gl-flex gl-justify-between': userModelSelectionEnabled }">
diff --git a/ee/app/assets/javascripts/ai/tanuki_bot/components/app.vue b/ee/app/assets/javascripts/ai/tanuki_bot/components/app.vue
index 392f611abc15e7..c16cc7d2c4c332 100644
--- a/ee/app/assets/javascripts/ai/tanuki_bot/components/app.vue
+++ b/ee/app/assets/javascripts/ai/tanuki_bot/components/app.vue
@@ -10,9 +10,13 @@ import { renderGFM } from '~/behaviors/markdown/render_gfm';
 import { helpPagePath } from '~/helpers/help_page_helper';
 import { getCookie } from '~/lib/utils/common_utils';
 import { duoChatGlobalState } from '~/super_sidebar/constants';
-import { clearDuoChatCommands, generateEventLabelFromText, setAgenticMode } from 'ee/ai/utils';
+import {
+  clearDuoChatCommands,
+  generateEventLabelFromText,
+  setAgenticMode,
+  shouldShowLoggingAlert,
+} from 'ee/ai/utils';
 import DuoChatCallout from 'ee/ai/components/global_callout/duo_chat_callout.vue';
-import DuoChatLoggingAlert from 'ee/ai/components/duo_chat_logging_alert.vue';
 import getAiMessages from 'ee/ai/graphql/get_ai_messages.query.graphql';
 import getAiConversationThreads from 'ee/ai/graphql/get_ai_conversation_threads.query.graphql';
 import getAiMessagesWithThread from 'ee/ai/graphql/get_ai_messages_with_thread.query.graphql';
@@ -60,7 +64,7 @@ export default {
     DuoChatCallout,
     TanukiBotSubscriptions,
     GlToggle,
-    DuoChatLoggingAlert,
+    DuoChatLoggingAlert: () => import('ee/ai/components/duo_chat_logging_alert.vue'),
   },
   mixins: [InternalEvents.mixin(), glFeatureFlagsMixin()],
   provide() {
@@ -221,6 +225,9 @@ export default {
     shouldRenderResizable() {
       return this.glFeatures.duoChatDynamicDimension;
     },
+    shouldShowLoggingAlert() {
+      return shouldShowLoggingAlert(this.metadata);
+    },
     dimensions() {
       return {
         width: this.width,
@@ -547,8 +554,8 @@ export default {
         @track-feedback="onTrackFeedback"
         @chat-resize="onChatResize"
       >
-        <template #subheader>
-          <duo-chat-logging-alert :metadata="metadata" />
+        <template v-if="shouldShowLoggingAlert" #subheader>
+          <duo-chat-logging-alert />
         </template>
         <template v-if="agenticAvailable" #footer-controls>
           <div class="gl-flex gl-px-4 gl-pb-2 gl-pt-5">
diff --git a/ee/app/assets/javascripts/ai/utils.js b/ee/app/assets/javascripts/ai/utils.js
index 7a9c9685830b5f..85c6b42923e9f7 100644
--- a/ee/app/assets/javascripts/ai/utils.js
+++ b/ee/app/assets/javascripts/ai/utils.js
@@ -91,6 +91,9 @@ export const generateEventLabelFromText = (text) => {
     .substring(0, 50);
 };
 
+export const shouldShowLoggingAlert = ({ isTeamMember, extendedLogging } = {}) =>
+  Boolean(isTeamMember && extendedLogging);
+
 export const utils = {
   concatStreamedChunks,
   generateEventLabelFromText,
diff --git a/ee/spec/frontend/ai/components/duo_chat_logging_alert_spec.js b/ee/spec/frontend/ai/components/duo_chat_logging_alert_spec.js
index 3d6d2f08e46bed..f3d06e4d3ee9e4 100644
--- a/ee/spec/frontend/ai/components/duo_chat_logging_alert_spec.js
+++ b/ee/spec/frontend/ai/components/duo_chat_logging_alert_spec.js
@@ -2,7 +2,7 @@ import { nextTick } from 'vue';
 import { GlAlert, GlSprintf } from '@gitlab/ui';
 import { shallowMountExtended } from 'helpers/vue_test_utils_helper';
 import { getCookie, setCookie } from '~/lib/utils/common_utils';
-import { DUO_AGENTIC_CHAT_LOGGING_ALERT } from 'ee/ai/constants';
+import { DUO_AGENTIC_CHAT_LOGGING_ALERT_DISMISSED_COOKIE } from 'ee/ai/constants';
 import DuoChatLoggingAlert from 'ee/ai/components/duo_chat_logging_alert.vue';
 
 jest.mock('~/lib/utils/common_utils', () => ({
@@ -134,7 +134,7 @@ describe('DuoChatLoggingAlert', () => {
       getCookie.mockReturnValue('true');
       createComponent();
 
-      expect(getCookie).toHaveBeenCalledWith(DUO_AGENTIC_CHAT_LOGGING_ALERT);
+      expect(getCookie).toHaveBeenCalledWith(DUO_AGENTIC_CHAT_LOGGING_ALERT_DISMISSED_COOKIE);
       expect(wrapper.vm.isDismissed).toBe(true);
       expect(findAlert().exists()).toBe(false);
     });
@@ -143,7 +143,7 @@ describe('DuoChatLoggingAlert', () => {
       createComponent();
       await nextTick();
 
-      expect(getCookie).toHaveBeenCalledWith(DUO_AGENTIC_CHAT_LOGGING_ALERT);
+      expect(getCookie).toHaveBeenCalledWith(DUO_AGENTIC_CHAT_LOGGING_ALERT_DISMISSED_COOKIE);
       expect(wrapper.vm.isDismissed).toBe(false);
       expect(findAlert().exists()).toBe(true);
     });
@@ -153,7 +153,7 @@ describe('DuoChatLoggingAlert', () => {
       createComponent();
       await nextTick();
 
-      expect(getCookie).toHaveBeenCalledWith(DUO_AGENTIC_CHAT_LOGGING_ALERT);
+      expect(getCookie).toHaveBeenCalledWith(DUO_AGENTIC_CHAT_LOGGING_ALERT_DISMISSED_COOKIE);
       expect(wrapper.vm.isDismissed).toBe(false);
       expect(findAlert().exists()).toBe(true);
     });
@@ -171,7 +171,7 @@ describe('DuoChatLoggingAlert', () => {
       alert.vm.$emit('dismiss');
       await nextTick();
 
-      expect(setCookie).toHaveBeenCalledWith(DUO_AGENTIC_CHAT_LOGGING_ALERT, true);
+      expect(setCookie).toHaveBeenCalledWith(DUO_AGENTIC_CHAT_LOGGING_ALERT_DISMISSED_COOKIE, true);
       expect(wrapper.vm.isDismissed).toBe(true);
       expect(findAlert().exists()).toBe(false);
     });
diff --git a/ee/spec/frontend/ai/duo_agentic_chat/components/app_spec.js b/ee/spec/frontend/ai/duo_agentic_chat/components/app_spec.js
index 5a123f90cbc489..68ae143afcbcaa 100644
--- a/ee/spec/frontend/ai/duo_agentic_chat/components/app_spec.js
+++ b/ee/spec/frontend/ai/duo_agentic_chat/components/app_spec.js
@@ -6,14 +6,13 @@ import VueApollo from 'vue-apollo';
 import { GlToggle } from '@gitlab/ui';
 import { shallowMountExtended } from 'helpers/vue_test_utils_helper';
 import { useLocalStorageSpy } from 'helpers/local_storage_helper';
-import { setAgenticMode } from 'ee/ai/utils';
+import { setAgenticMode, shouldShowLoggingAlert } from 'ee/ai/utils';
 import createMockApollo from 'helpers/mock_apollo_helper';
 import waitForPromises from 'helpers/wait_for_promises';
 import { duoChatGlobalState } from '~/super_sidebar/constants';
 import getUserWorkflows from 'ee/ai/graphql/get_user_workflow.query.graphql';
 import getAiChatContextPresets from 'ee/ai/graphql/get_ai_chat_context_presets.query.graphql';
 import DuoAgenticChatApp from 'ee/ai/duo_agentic_chat/components/app.vue';
-import DuoChatLoggingAlert from 'ee/ai/components/duo_chat_logging_alert.vue';
 import { ApolloUtils } from 'ee/ai/duo_agentic_chat/utils/apollo_utils';
 import { WorkflowUtils } from 'ee/ai/duo_agentic_chat/utils/workflow_utils';
 import ModelSelectDropdown from 'ee/ai/shared/feature_settings/model_select_dropdown.vue';
@@ -173,6 +172,7 @@ jest.mock('ee/ai/utils', () => {
     __esModule: true,
     ...actualUtils,
     setAgenticMode: jest.fn(),
+    shouldShowLoggingAlert: jest.fn(),
   };
 });
 
@@ -191,7 +191,7 @@ describe('Duo Agentic Chat', () => {
   const contextPresetsQueryHandlerMock = jest.fn().mockResolvedValue(MOCK_CONTEXT_PRESETS_RESPONSE);
 
   const findDuoChat = () => wrapper.findComponent(AgenticDuoChat);
-  const findLoggingAlert = () => wrapper.findComponent(DuoChatLoggingAlert);
+  const findLoggingAlert = () => wrapper.findComponent({ name: 'DuoChatLoggingAlert' });
   const findGlToggle = () => wrapper.findComponent(GlToggle);
   const getLastSocketCall = () => {
     const { calls } = createWebSocket.mock;
@@ -341,17 +341,31 @@ describe('Duo Agentic Chat', () => {
   describe('DuoChatLoggingAlert Integration', () => {
     beforeEach(() => {
       duoChatGlobalState.isAgenticChatShown = true;
+      shouldShowLoggingAlert.mockReturnValue(true);
     });
 
-    it('renders DuoChatLoggingAlert with correct props', () => {
-      const metadata = { is_team_member: true, extended_logging: true };
+    it('renders DuoChatLoggingAlert when shouldShowLoggingAlert returns true', () => {
+      const metadata = { isTeamMember: true, extendedLogging: true };
+      shouldShowLoggingAlert.mockReturnValue(true);
+
       createComponent({ propsData: { metadata } });
 
+      expect(shouldShowLoggingAlert).toHaveBeenCalledWith(metadata);
       expect(findLoggingAlert().exists()).toBe(true);
-      expect(findLoggingAlert().props('metadata')).toEqual(metadata);
     });
 
-    it('renders DuoChatLoggingAlert in the subheader slot', () => {
+    it('does not render DuoChatLoggingAlert when shouldShowLoggingAlert returns false', () => {
+      const metadata = { isTeamMember: false, extendedLogging: false };
+      shouldShowLoggingAlert.mockReturnValue(false);
+
+      createComponent({ propsData: { metadata } });
+
+      expect(shouldShowLoggingAlert).toHaveBeenCalledWith(metadata);
+      expect(findLoggingAlert().exists()).toBe(false);
+    });
+
+    it('renders DuoChatLoggingAlert in the subheader slot when shown', () => {
+      shouldShowLoggingAlert.mockReturnValue(true);
       createComponent();
 
       expect(findDuoChat().vm.$slots.subheader).toBeDefined();
diff --git a/ee/spec/frontend/ai/tanuki_bot/components/app_spec.js b/ee/spec/frontend/ai/tanuki_bot/components/app_spec.js
index df722676248877..232e8fe019ab99 100644
--- a/ee/spec/frontend/ai/tanuki_bot/components/app_spec.js
+++ b/ee/spec/frontend/ai/tanuki_bot/components/app_spec.js
@@ -5,10 +5,9 @@ import { v4 as uuidv4 } from 'uuid';
 import Vuex from 'vuex';
 import VueApollo from 'vue-apollo';
 import { GlToggle } from '@gitlab/ui';
-import { sendDuoChatCommand, setAgenticMode } from 'ee/ai/utils';
+import { sendDuoChatCommand, setAgenticMode, shouldShowLoggingAlert } from 'ee/ai/utils';
 import TanukiBotChatApp from 'ee/ai/tanuki_bot/components/app.vue';
 import DuoChatCallout from 'ee/ai/components/global_callout/duo_chat_callout.vue';
-import DuoChatLoggingAlert from 'ee/ai/components/duo_chat_logging_alert.vue';
 import TanukiBotSubscriptions from 'ee/ai/tanuki_bot/components/tanuki_bot_subscriptions.vue';
 import {
   GENIE_CHAT_RESET_MESSAGE,
@@ -67,6 +66,7 @@ jest.mock('ee/ai/utils', () => {
     __esModule: true,
     ...actualUtils,
     setAgenticMode: jest.fn(),
+    shouldShowLoggingAlert: jest.fn(),
   };
 });
 
@@ -117,7 +117,7 @@ describeSkipVue3(skipReason, () => {
 
   const findCallout = () => wrapper.findComponent(DuoChatCallout);
   const findSubscriptions = () => wrapper.findComponent(TanukiBotSubscriptions);
-  const findLoggingAlert = () => wrapper.findComponent(DuoChatLoggingAlert);
+  const findLoggingAlert = () => wrapper.findComponent({ name: 'DuoChatLoggingAlert' });
 
   const createComponent = ({
     initialState = {},
@@ -299,10 +299,13 @@ describeSkipVue3(skipReason, () => {
   describe('DuoChatLoggingAlert Integration', () => {
     beforeEach(() => {
       duoChatGlobalState.isShown = true;
+      shouldShowLoggingAlert.mockReturnValue(true);
     });
 
-    it('renders DuoChatLoggingAlert with correct props', () => {
-      const metadata = { is_team_member: true, extended_logging: true };
+    it('renders DuoChatLoggingAlert when shouldShowLoggingAlert returns true', () => {
+      const metadata = { isTeamMember: true, extendedLogging: true };
+      shouldShowLoggingAlert.mockReturnValue(true);
+
       createComponent({
         propsData: {
           userId: MOCK_USER_ID,
@@ -311,11 +314,28 @@ describeSkipVue3(skipReason, () => {
         },
       });
 
+      expect(shouldShowLoggingAlert).toHaveBeenCalledWith(metadata);
       expect(findLoggingAlert().exists()).toBe(true);
-      expect(findLoggingAlert().props('metadata')).toEqual(metadata);
     });
 
-    it('renders DuoChatLoggingAlert in the subheader slot', () => {
+    it('does not render DuoChatLoggingAlert when shouldShowLoggingAlert returns false', () => {
+      const metadata = { isTeamMember: false, extendedLogging: false };
+      shouldShowLoggingAlert.mockReturnValue(false);
+
+      createComponent({
+        propsData: {
+          userId: MOCK_USER_ID,
+          resourceId: MOCK_RESOURCE_ID,
+          metadata,
+        },
+      });
+
+      expect(shouldShowLoggingAlert).toHaveBeenCalledWith(metadata);
+      expect(findLoggingAlert().exists()).toBe(false);
+    });
+
+    it('renders DuoChatLoggingAlert in the subheader slot when shown', () => {
+      shouldShowLoggingAlert.mockReturnValue(true);
       createComponent();
 
       expect(findDuoChat().vm.$slots.subheader).toBeDefined();
diff --git a/ee/spec/frontend/ai/utils_spec.js b/ee/spec/frontend/ai/utils_spec.js
index ac32af2a7d7231..7c8e9c95f94aa0 100644
--- a/ee/spec/frontend/ai/utils_spec.js
+++ b/ee/spec/frontend/ai/utils_spec.js
@@ -5,6 +5,7 @@ import {
   utils,
   setAgenticMode,
   saveDuoAgenticModePreference,
+  shouldShowLoggingAlert,
 } from 'ee/ai/utils';
 import { duoChatGlobalState } from '~/super_sidebar/constants';
 import { setCookie } from '~/lib/utils/common_utils';
@@ -354,4 +355,48 @@ describe('AI Utils', () => {
       );
     });
   });
+
+  describe('shouldShowLoggingAlert', () => {
+    it('returns true when both isTeamMember and extendedLogging are true', () => {
+      const metadata = { isTeamMember: true, extendedLogging: true };
+      expect(shouldShowLoggingAlert(metadata)).toBe(true);
+    });
+
+    it('returns false when isTeamMember is false', () => {
+      const metadata = { isTeamMember: false, extendedLogging: true };
+      expect(shouldShowLoggingAlert(metadata)).toBe(false);
+    });
+
+    it('returns false when extendedLogging is false', () => {
+      const metadata = { isTeamMember: true, extendedLogging: false };
+      expect(shouldShowLoggingAlert(metadata)).toBe(false);
+    });
+
+    it('returns false when both isTeamMember and extendedLogging are false', () => {
+      const metadata = { isTeamMember: false, extendedLogging: false };
+      expect(shouldShowLoggingAlert(metadata)).toBe(false);
+    });
+
+    it('returns false when metadata is undefined', () => {
+      expect(shouldShowLoggingAlert(undefined)).toBe(false);
+    });
+
+    it('returns false when metadata is null', () => {
+      expect(shouldShowLoggingAlert(null)).toBe(false);
+    });
+
+    it('returns false when metadata is an empty object', () => {
+      expect(shouldShowLoggingAlert({})).toBe(false);
+    });
+
+    it('returns false when isTeamMember is missing', () => {
+      const metadata = { extendedLogging: true };
+      expect(shouldShowLoggingAlert(metadata)).toBe(false);
+    });
+
+    it('returns false when extendedLogging is missing', () => {
+      const metadata = { isTeamMember: true };
+      expect(shouldShowLoggingAlert(metadata)).toBe(false);
+    });
+  });
 });
-- 
GitLab


From 13efd59da07dea51fbd98e5ce19490d1e0d5fb21 Mon Sep 17 00:00:00 2001
From: Tomas Bulva <tbulva@gitlab.com>
Date: Wed, 27 Aug 2025 21:26:41 +0200
Subject: [PATCH 4/8] additional changes

---
 .../ai/duo_agentic_chat/components/app.vue     |  4 ++--
 .../javascripts/ai/duo_agentic_chat/index.js   | 17 +----------------
 .../ai/tanuki_bot/components/app.vue           |  2 +-
 .../assets/javascripts/ai/tanuki_bot/index.js  | 18 ++----------------
 ee/app/assets/javascripts/ai/utils.js          | 18 +++++++++++++++++-
 5 files changed, 23 insertions(+), 36 deletions(-)

diff --git a/ee/app/assets/javascripts/ai/duo_agentic_chat/components/app.vue b/ee/app/assets/javascripts/ai/duo_agentic_chat/components/app.vue
index a6cce5a61f5049..d4490ba2662350 100644
--- a/ee/app/assets/javascripts/ai/duo_agentic_chat/components/app.vue
+++ b/ee/app/assets/javascripts/ai/duo_agentic_chat/components/app.vue
@@ -67,7 +67,7 @@ export default {
       default: null,
     },
     metadata: {
-      type: Object,
+      type: String,
       required: false,
       default: null,
     },
@@ -292,7 +292,7 @@ export default {
           workflowID: this.workflowId,
           clientVersion: DUO_WORKFLOW_CLIENT_VERSION,
           workflowDefinition: DUO_WORKFLOW_CHAT_DEFINITION,
-          workflowMetadata: this.metadata && JSON.stringify(this.metadata),
+          workflowMetadata: this.metadata,
           goal,
           approval,
         },
diff --git a/ee/app/assets/javascripts/ai/duo_agentic_chat/index.js b/ee/app/assets/javascripts/ai/duo_agentic_chat/index.js
index a39c9cc2f8b135..b2e5ac783c5b22 100644
--- a/ee/app/assets/javascripts/ai/duo_agentic_chat/index.js
+++ b/ee/app/assets/javascripts/ai/duo_agentic_chat/index.js
@@ -1,10 +1,8 @@
 import Vue from 'vue';
 import VueApollo from 'vue-apollo';
-import * as Sentry from '~/sentry/sentry_browser_wrapper';
 import createDefaultClient from '~/lib/graphql';
 import { parseBoolean } from '~/lib/utils/common_utils';
 import { activeWorkItemIds } from '~/work_items/utils';
-import { convertObjectPropsToCamelCase } from '~/lib/utils/common_utils';
 import store from '../tanuki_bot/store';
 import DuoAgenticChatApp from './components/app.vue';
 
@@ -16,25 +14,12 @@ const apolloProvider = new VueApollo({
 
 export const initDuoAgenticChat = () => {
   const el = document.getElementById('js-duo-agentic-chat-app');
-  let notConvertedMetadata = {};
 
   if (!el) {
     return false;
   }
 
-  const { projectId, namespaceId, resourceId, userModelSelectionEnabled } = el.dataset;
-
-  try {
-    notConvertedMetadata = JSON.parse(el.dataset.metadata);
-  } catch (error) {
-    Sentry.captureException(error);
-    notConvertedMetadata = {
-      extended_logging: false,
-      is_team_member: false,
-    };
-  }
-
-  const metadata = convertObjectPropsToCamelCase(notConvertedMetadata);
+  const { projectId, namespaceId, resourceId, metadata, userModelSelectionEnabled } = el.dataset;
 
   return new Vue({
     el,
diff --git a/ee/app/assets/javascripts/ai/tanuki_bot/components/app.vue b/ee/app/assets/javascripts/ai/tanuki_bot/components/app.vue
index c16cc7d2c4c332..3148d69d4baf72 100644
--- a/ee/app/assets/javascripts/ai/tanuki_bot/components/app.vue
+++ b/ee/app/assets/javascripts/ai/tanuki_bot/components/app.vue
@@ -104,7 +104,7 @@ export default {
       default: false,
     },
     metadata: {
-      type: Object,
+      type: String,
       required: false,
       default: null,
     },
diff --git a/ee/app/assets/javascripts/ai/tanuki_bot/index.js b/ee/app/assets/javascripts/ai/tanuki_bot/index.js
index 11b6fd038972fd..e9228286a40e50 100644
--- a/ee/app/assets/javascripts/ai/tanuki_bot/index.js
+++ b/ee/app/assets/javascripts/ai/tanuki_bot/index.js
@@ -1,9 +1,8 @@
 import Vue from 'vue';
 import VueApollo from 'vue-apollo';
-import * as Sentry from '~/sentry/sentry_browser_wrapper';
 import createDefaultClient from '~/lib/graphql';
 import { duoChatGlobalState } from '~/super_sidebar/constants';
-import { getCookie, convertObjectPropsToCamelCase } from '~/lib/utils/common_utils';
+import { getCookie } from '~/lib/utils/common_utils';
 import { DUO_AGENTIC_MODE_COOKIE } from 'ee/ai/tanuki_bot/constants';
 import TanukiBotChatApp from './components/app.vue';
 import store from './store';
@@ -16,27 +15,14 @@ const apolloProvider = new VueApollo({
 
 export const initTanukiBotChatDrawer = () => {
   const el = document.getElementById('js-tanuki-bot-chat-app');
-  let notConvertedMetadata = {};
 
   if (!el) {
     return false;
   }
 
-  const { userId, resourceId, projectId, chatTitle, rootNamespaceId, agenticAvailable } =
+  const { userId, resourceId, projectId, chatTitle, rootNamespaceId, agenticAvailable, metadata } =
     el.dataset;
 
-  try {
-    notConvertedMetadata = JSON.parse(el.dataset.metadata);
-  } catch (error) {
-    Sentry.captureException(error);
-    notConvertedMetadata = {
-      extended_logging: false,
-      is_team_member: false,
-    };
-  }
-
-  const metadata = convertObjectPropsToCamelCase(notConvertedMetadata);
-
   const toggleEls = document.querySelectorAll('.js-tanuki-bot-chat-toggle');
   if (toggleEls.length) {
     toggleEls.forEach((toggleEl) => {
diff --git a/ee/app/assets/javascripts/ai/utils.js b/ee/app/assets/javascripts/ai/utils.js
index 85c6b42923e9f7..2de5fa2ae1159e 100644
--- a/ee/app/assets/javascripts/ai/utils.js
+++ b/ee/app/assets/javascripts/ai/utils.js
@@ -1,5 +1,6 @@
 import { duoChatGlobalState } from '~/super_sidebar/constants';
 import { setCookie } from '~/lib/utils/common_utils';
+import * as Sentry from '~/sentry/sentry_browser_wrapper';
 import {
   DUO_AGENTIC_MODE_COOKIE,
   DUO_AGENTIC_MODE_COOKIE_EXPIRATION,
@@ -91,8 +92,23 @@ export const generateEventLabelFromText = (text) => {
     .substring(0, 50);
 };
 
-export const shouldShowLoggingAlert = ({ isTeamMember, extendedLogging } = {}) =>
+export const shouldShowLoggingAlert = (metadata = '') => {
+  let convertedMetadata;
+
+  try {
+    convertedMetadata = JSON.parse(metadata);
+  } catch (error) {
+    Sentry.captureException(error);
+    convertedMetadata = {
+      extended_logging: false,
+      is_team_member: false,
+    };
+  }
+
+  const { extended_logging: extendedLogging, is_team_member: isTeamMember } = convertedMetadata;
+
   Boolean(isTeamMember && extendedLogging);
+};
 
 export const utils = {
   concatStreamedChunks,
-- 
GitLab


From 1f61aa1f58be79e538ace35a1e7acdf5f24789d3 Mon Sep 17 00:00:00 2001
From: Tomas Bulva <tbulva@gitlab.com>
Date: Thu, 28 Aug 2025 14:13:06 +0200
Subject: [PATCH 5/8] Fixed tests. Added Mark Florian test diff.

---
 ee/app/assets/javascripts/ai/utils.js         |  9 +-
 .../components/duo_chat_logging_alert_spec.js | 99 +------------------
 .../duo_agentic_chat/components/app_spec.js   | 64 ++++++------
 .../ai/tanuki_bot/components/app_spec.js      | 11 +--
 ee/spec/frontend/ai/utils_spec.js             | 68 ++++++-------
 5 files changed, 79 insertions(+), 172 deletions(-)

diff --git a/ee/app/assets/javascripts/ai/utils.js b/ee/app/assets/javascripts/ai/utils.js
index 2de5fa2ae1159e..90b9e392ea3078 100644
--- a/ee/app/assets/javascripts/ai/utils.js
+++ b/ee/app/assets/javascripts/ai/utils.js
@@ -99,15 +99,12 @@ export const shouldShowLoggingAlert = (metadata = '') => {
     convertedMetadata = JSON.parse(metadata);
   } catch (error) {
     Sentry.captureException(error);
-    convertedMetadata = {
-      extended_logging: false,
-      is_team_member: false,
-    };
   }
 
-  const { extended_logging: extendedLogging, is_team_member: isTeamMember } = convertedMetadata;
+  const { extended_logging: extendedLogging, is_team_member: isTeamMember } =
+    convertedMetadata ?? {};
 
-  Boolean(isTeamMember && extendedLogging);
+  return Boolean(isTeamMember && extendedLogging);
 };
 
 export const utils = {
diff --git a/ee/spec/frontend/ai/components/duo_chat_logging_alert_spec.js b/ee/spec/frontend/ai/components/duo_chat_logging_alert_spec.js
index f3d06e4d3ee9e4..4bbbf569e9efa8 100644
--- a/ee/spec/frontend/ai/components/duo_chat_logging_alert_spec.js
+++ b/ee/spec/frontend/ai/components/duo_chat_logging_alert_spec.js
@@ -13,12 +13,8 @@ jest.mock('~/lib/utils/common_utils', () => ({
 describe('DuoChatLoggingAlert', () => {
   let wrapper;
 
-  const createComponent = (props = { metadata: { isTeamMember: true, extendedLogging: true } }) => {
-    wrapper = shallowMountExtended(DuoChatLoggingAlert, {
-      propsData: {
-        ...props,
-      },
-    });
+  const createComponent = () => {
+    wrapper = shallowMountExtended(DuoChatLoggingAlert);
   };
 
   const findAlert = () => wrapper.findComponent(GlAlert);
@@ -29,63 +25,19 @@ describe('DuoChatLoggingAlert', () => {
   });
 
   describe('Alert visibility', () => {
-    it('renders alert when user is team member, extendedLogging is true, and alert is not dismissed', async () => {
+    it('alert is not dismissed', async () => {
       createComponent();
       await nextTick();
 
       expect(findAlert().exists()).toBe(true);
     });
 
-    it('does not render alert when user is not a team member', () => {
-      createComponent({
-        metadata: { isTeamMember: false, extendedLogging: true },
-      });
-
-      expect(findAlert().exists()).toBe(false);
-    });
-
-    it('does not render alert when extendedLogging is false', () => {
-      createComponent({
-        metadata: { isTeamMember: true, extendedLogging: false },
-      });
-
-      expect(findAlert().exists()).toBe(false);
-    });
-
-    it('does not render alert when extendedLogging is undefined', () => {
-      createComponent({
-        metadata: { isTeamMember: true },
-      });
-
-      expect(findAlert().exists()).toBe(false);
-    });
-
-    it('does not render alert when user is team member but alert was dismissed', () => {
+    it('does not render alert when dismissed', () => {
       getCookie.mockReturnValue('true');
       createComponent();
 
       expect(findAlert().exists()).toBe(false);
     });
-
-    it('does not render alert when metadata is undefined', () => {
-      createComponent({ metadata: undefined });
-
-      expect(findAlert().exists()).toBe(false);
-    });
-
-    it('does not render alert when metadata is null', () => {
-      createComponent({ metadata: null });
-
-      expect(findAlert().exists()).toBe(false);
-    });
-
-    it('does not render alert when metadata.is_team_member is undefined', () => {
-      createComponent({
-        metadata: { extendedLogging: true },
-      });
-
-      expect(findAlert().exists()).toBe(false);
-    });
   });
 
   describe('Alert properties', () => {
@@ -135,7 +87,6 @@ describe('DuoChatLoggingAlert', () => {
       createComponent();
 
       expect(getCookie).toHaveBeenCalledWith(DUO_AGENTIC_CHAT_LOGGING_ALERT_DISMISSED_COOKIE);
-      expect(wrapper.vm.isDismissed).toBe(true);
       expect(findAlert().exists()).toBe(false);
     });
 
@@ -144,7 +95,6 @@ describe('DuoChatLoggingAlert', () => {
       await nextTick();
 
       expect(getCookie).toHaveBeenCalledWith(DUO_AGENTIC_CHAT_LOGGING_ALERT_DISMISSED_COOKIE);
-      expect(wrapper.vm.isDismissed).toBe(false);
       expect(findAlert().exists()).toBe(true);
     });
 
@@ -154,7 +104,6 @@ describe('DuoChatLoggingAlert', () => {
       await nextTick();
 
       expect(getCookie).toHaveBeenCalledWith(DUO_AGENTIC_CHAT_LOGGING_ALERT_DISMISSED_COOKIE);
-      expect(wrapper.vm.isDismissed).toBe(false);
       expect(findAlert().exists()).toBe(true);
     });
   });
@@ -172,7 +121,6 @@ describe('DuoChatLoggingAlert', () => {
       await nextTick();
 
       expect(setCookie).toHaveBeenCalledWith(DUO_AGENTIC_CHAT_LOGGING_ALERT_DISMISSED_COOKIE, true);
-      expect(wrapper.vm.isDismissed).toBe(true);
       expect(findAlert().exists()).toBe(false);
     });
 
@@ -188,43 +136,4 @@ describe('DuoChatLoggingAlert', () => {
       onDismissSpy.mockRestore();
     });
   });
-
-  describe('hasAlert computed property', () => {
-    it.each`
-      isTeamMember | extendedLogging | isDismissed | expected | scenario
-      ${true}      | ${true}         | ${false}    | ${true}  | ${'shows when all conditions are met'}
-      ${false}     | ${true}         | ${false}    | ${false} | ${'hides when not team member'}
-      ${true}      | ${false}        | ${false}    | ${false} | ${'hides when extended_logging is false'}
-      ${true}      | ${undefined}    | ${false}    | ${false} | ${'hides when extended_logging is undefined'}
-      ${true}      | ${true}         | ${true}     | ${false} | ${'hides when dismissed'}
-      ${undefined} | ${true}         | ${false}    | ${false} | ${'hides when is_team_member is undefined'}
-    `('$scenario', async ({ isTeamMember, extendedLogging, isDismissed, expected }) => {
-      getCookie.mockReturnValue(isDismissed ? 'true' : null);
-      createComponent({
-        metadata: {
-          isTeamMember,
-          extendedLogging,
-        },
-      });
-      await nextTick();
-
-      expect(findAlert().exists()).toBe(expected);
-    });
-  });
-
-  describe('Props validation', () => {
-    it('handles null metadata prop', () => {
-      createComponent({ metadata: null });
-
-      expect(() => wrapper.vm).not.toThrow();
-      expect(findAlert().exists()).toBe(false);
-    });
-
-    it('handles undefined metadata prop', () => {
-      createComponent({ metadata: undefined });
-
-      expect(() => wrapper.vm).not.toThrow();
-      expect(findAlert().exists()).toBe(false);
-    });
-  });
 });
diff --git a/ee/spec/frontend/ai/duo_agentic_chat/components/app_spec.js b/ee/spec/frontend/ai/duo_agentic_chat/components/app_spec.js
index 68ae143afcbcaa..1830dac21fdc85 100644
--- a/ee/spec/frontend/ai/duo_agentic_chat/components/app_spec.js
+++ b/ee/spec/frontend/ai/duo_agentic_chat/components/app_spec.js
@@ -191,7 +191,6 @@ describe('Duo Agentic Chat', () => {
   const contextPresetsQueryHandlerMock = jest.fn().mockResolvedValue(MOCK_CONTEXT_PRESETS_RESPONSE);
 
   const findDuoChat = () => wrapper.findComponent(AgenticDuoChat);
-  const findLoggingAlert = () => wrapper.findComponent({ name: 'DuoChatLoggingAlert' });
   const findGlToggle = () => wrapper.findComponent(GlToggle);
   const getLastSocketCall = () => {
     const { calls } = createWebSocket.mock;
@@ -205,7 +204,7 @@ describe('Duo Agentic Chat', () => {
   const defaultPropsData = {
     projectId: MOCK_PROJECT_ID,
     resourceId: MOCK_RESOURCE_ID,
-    metadata: { is_team_member: true, extended_logging: true },
+    metadata: JSON.stringify({ is_team_member: true, extended_logging: true }),
   };
 
   const createComponent = ({ initialState = {}, propsData = {} } = {}) => {
@@ -345,31 +344,29 @@ describe('Duo Agentic Chat', () => {
     });
 
     it('renders DuoChatLoggingAlert when shouldShowLoggingAlert returns true', () => {
-      const metadata = { isTeamMember: true, extendedLogging: true };
+      const metadata = JSON.stringify({ is_team_member: true, extended_logging: true });
       shouldShowLoggingAlert.mockReturnValue(true);
 
       createComponent({ propsData: { metadata } });
 
       expect(shouldShowLoggingAlert).toHaveBeenCalledWith(metadata);
-      expect(findLoggingAlert().exists()).toBe(true);
     });
 
     it('does not render DuoChatLoggingAlert when shouldShowLoggingAlert returns false', () => {
-      const metadata = { isTeamMember: false, extendedLogging: false };
+      const metadata = JSON.stringify({ is_team_member: false, extended_logging: false });
       shouldShowLoggingAlert.mockReturnValue(false);
 
       createComponent({ propsData: { metadata } });
 
       expect(shouldShowLoggingAlert).toHaveBeenCalledWith(metadata);
-      expect(findLoggingAlert().exists()).toBe(false);
+      expect(findDuoChat().vm.$slots.subheader).toBeUndefined();
     });
 
     it('renders DuoChatLoggingAlert in the subheader slot when shown', () => {
       shouldShowLoggingAlert.mockReturnValue(true);
       createComponent();
 
-      expect(findDuoChat().vm.$slots.subheader).toBeDefined();
-      expect(findLoggingAlert().exists()).toBe(true);
+      expect(wrapper.vm.shouldShowLoggingAlert).toBe(true);
     });
 
     it('does not render DuoChatLoggingAlert when Duo Chat is not shown', () => {
@@ -377,7 +374,6 @@ describe('Duo Agentic Chat', () => {
       createComponent();
 
       expect(findDuoChat().exists()).toBe(false);
-      expect(findLoggingAlert().exists()).toBe(false);
     });
   });
 
@@ -622,12 +618,18 @@ describe('Duo Agentic Chat', () => {
         );
         expect(findDuoChat().props('activeThreadId')).toBe('Test goal for activeThread');
       });
+
       describe('startWorkflow request structure validation', () => {
         describe('required fields validation', () => {
-          beforeEach(async () => {
-            createComponent();
-            duoChatGlobalState.isAgenticChatShown = true;
-            await waitForPromises();
+          beforeEach(() => {
+            mockSocketManager.connect.mockClear();
+            createComponent({
+              propsData: {
+                projectId: MOCK_PROJECT_ID,
+                resourceId: MOCK_RESOURCE_ID,
+                metadata: JSON.stringify({ is_team_member: true, extended_logging: true }),
+              },
+            });
           });
 
           afterEach(() => {
@@ -635,6 +637,13 @@ describe('Duo Agentic Chat', () => {
           });
 
           it('sends all required fields according to protobuf schema', async () => {
+            contextPresetsQueryHandlerMock.mockResolvedValueOnce({
+              data: { aiChatContextPresets: { questions: [], aiResourceData: null } },
+            });
+
+            duoChatGlobalState.isAgenticChatShown = true;
+            await waitForPromises();
+
             findDuoChat().vm.$emit('send-chat-prompt', 'test question');
             await waitForPromises();
 
@@ -654,6 +663,13 @@ describe('Duo Agentic Chat', () => {
           });
 
           it('validates field types match protobuf schema', async () => {
+            contextPresetsQueryHandlerMock.mockResolvedValueOnce({
+              data: { aiChatContextPresets: { questions: [], aiResourceData: null } },
+            });
+
+            duoChatGlobalState.isAgenticChatShown = true;
+            await waitForPromises();
+
             findDuoChat().vm.$emit('send-chat-prompt', 'test question');
             await waitForPromises();
 
@@ -674,19 +690,8 @@ describe('Duo Agentic Chat', () => {
         });
 
         describe('metadata field handling', () => {
-          beforeEach(async () => {
-            createComponent();
-            duoChatGlobalState.isAgenticChatShown = true;
-            await waitForPromises();
-            mockSocketManager.connect.mockClear(); // Clear calls from the default component
-          });
-
-          afterEach(() => {
+          beforeEach(() => {
             mockSocketManager.connect.mockClear();
-            if (wrapper) {
-              wrapper.destroy();
-              wrapper = null;
-            }
           });
 
           it('stringifies metadata object correctly', async () => {
@@ -699,9 +704,10 @@ describe('Duo Agentic Chat', () => {
               propsData: {
                 projectId: MOCK_PROJECT_ID,
                 resourceId: MOCK_RESOURCE_ID,
-                metadata,
+                metadata: JSON.stringify(metadata),
               },
             });
+
             duoChatGlobalState.isAgenticChatShown = true;
             await waitForPromises();
 
@@ -754,7 +760,7 @@ describe('Duo Agentic Chat', () => {
               propsData: {
                 projectId: MOCK_PROJECT_ID,
                 resourceId: MOCK_RESOURCE_ID,
-                metadata: {},
+                metadata: '{}',
               },
             });
             duoChatGlobalState.isAgenticChatShown = true;
@@ -800,7 +806,7 @@ describe('Duo Agentic Chat', () => {
               propsData: {
                 projectId: MOCK_PROJECT_ID,
                 resourceId: MOCK_RESOURCE_ID,
-                metadata: { is_team_member: true, extended_logging: true },
+                metadata: JSON.stringify({ is_team_member: true, extended_logging: true }),
               },
             });
 
@@ -1641,7 +1647,7 @@ describe('Duo Agentic Chat', () => {
       createComponent();
     });
 
-    it('renders the GlToggle component in footer-controls', () => {
+    it('renders the GlToggle component', () => {
       expect(findGlToggle().exists()).toBe(true);
     });
 
diff --git a/ee/spec/frontend/ai/tanuki_bot/components/app_spec.js b/ee/spec/frontend/ai/tanuki_bot/components/app_spec.js
index 232e8fe019ab99..39af7fa94463ce 100644
--- a/ee/spec/frontend/ai/tanuki_bot/components/app_spec.js
+++ b/ee/spec/frontend/ai/tanuki_bot/components/app_spec.js
@@ -303,7 +303,7 @@ describeSkipVue3(skipReason, () => {
     });
 
     it('renders DuoChatLoggingAlert when shouldShowLoggingAlert returns true', () => {
-      const metadata = { isTeamMember: true, extendedLogging: true };
+      const metadata = JSON.stringify({ is_team_member: true, extended_logging: true });
       shouldShowLoggingAlert.mockReturnValue(true);
 
       createComponent({
@@ -315,11 +315,11 @@ describeSkipVue3(skipReason, () => {
       });
 
       expect(shouldShowLoggingAlert).toHaveBeenCalledWith(metadata);
-      expect(findLoggingAlert().exists()).toBe(true);
+      expect(wrapper.vm.shouldShowLoggingAlert).toBe(true);
     });
 
     it('does not render DuoChatLoggingAlert when shouldShowLoggingAlert returns false', () => {
-      const metadata = { isTeamMember: false, extendedLogging: false };
+      const metadata = JSON.stringify({ is_team_member: false, extended_logging: false });
       shouldShowLoggingAlert.mockReturnValue(false);
 
       createComponent({
@@ -331,15 +331,14 @@ describeSkipVue3(skipReason, () => {
       });
 
       expect(shouldShowLoggingAlert).toHaveBeenCalledWith(metadata);
-      expect(findLoggingAlert().exists()).toBe(false);
+      expect(wrapper.vm.shouldShowLoggingAlert).toBe(false);
     });
 
     it('renders DuoChatLoggingAlert in the subheader slot when shown', () => {
       shouldShowLoggingAlert.mockReturnValue(true);
       createComponent();
 
-      expect(findDuoChat().vm.$slots.subheader).toBeDefined();
-      expect(findLoggingAlert().exists()).toBe(true);
+      expect(wrapper.vm.shouldShowLoggingAlert).toBe(true);
     });
 
     it('does not render DuoChatLoggingAlert when Duo Chat is not shown', () => {
diff --git a/ee/spec/frontend/ai/utils_spec.js b/ee/spec/frontend/ai/utils_spec.js
index 7c8e9c95f94aa0..39fe5f157b9f8c 100644
--- a/ee/spec/frontend/ai/utils_spec.js
+++ b/ee/spec/frontend/ai/utils_spec.js
@@ -13,11 +13,16 @@ import {
   DUO_AGENTIC_MODE_COOKIE,
   DUO_AGENTIC_MODE_COOKIE_EXPIRATION,
 } from 'ee/ai/tanuki_bot/constants';
+import * as Sentry from '~/sentry/sentry_browser_wrapper';
 
 jest.mock('~/lib/utils/common_utils', () => ({
   setCookie: jest.fn(),
 }));
 
+jest.mock('~/sentry/sentry_browser_wrapper', () => ({
+  captureException: jest.fn(),
+}));
+
 describe('AI Utils', () => {
   describe('concatStreamedChunks', () => {
     it.each`
@@ -357,46 +362,37 @@ describe('AI Utils', () => {
   });
 
   describe('shouldShowLoggingAlert', () => {
-    it('returns true when both isTeamMember and extendedLogging are true', () => {
-      const metadata = { isTeamMember: true, extendedLogging: true };
-      expect(shouldShowLoggingAlert(metadata)).toBe(true);
-    });
-
-    it('returns false when isTeamMember is false', () => {
-      const metadata = { isTeamMember: false, extendedLogging: true };
-      expect(shouldShowLoggingAlert(metadata)).toBe(false);
-    });
-
-    it('returns false when extendedLogging is false', () => {
-      const metadata = { isTeamMember: true, extendedLogging: false };
-      expect(shouldShowLoggingAlert(metadata)).toBe(false);
-    });
-
-    it('returns false when both isTeamMember and extendedLogging are false', () => {
-      const metadata = { isTeamMember: false, extendedLogging: false };
-      expect(shouldShowLoggingAlert(metadata)).toBe(false);
-    });
-
-    it('returns false when metadata is undefined', () => {
-      expect(shouldShowLoggingAlert(undefined)).toBe(false);
-    });
+    it.each`
+      is_team_member | extended_logging | expectedValue
+      ${true}        | ${true}          | ${true}
+      ${true}        | ${false}         | ${false}
+      ${false}       | ${true}          | ${false}
+      ${false}       | ${false}         | ${false}
+      ${true}        | ${undefined}     | ${false}
+      ${undefined}   | ${true}          | ${false}
+      ${undefined}   | ${undefined}     | ${false}
+    `(
+      'returns $expectedValue when is_team_member=$is_team_member, extended_logging=$extended_logging',
+      ({ is_team_member, extended_logging, expectedValue }) => {
+        const metadata = JSON.stringify({ is_team_member, extended_logging });
+        expect(shouldShowLoggingAlert(metadata)).toBe(expectedValue);
+        expect(Sentry.captureException).not.toHaveBeenCalled();
+      },
+    );
 
     it('returns false when metadata is null', () => {
+      // `null` stringifies to `"null"`, which then parses back to `null`, so no error is thrown.
+      // TODO: Is this acceptable?
       expect(shouldShowLoggingAlert(null)).toBe(false);
+      expect(Sentry.captureException).not.toHaveBeenCalled();
     });
 
-    it('returns false when metadata is an empty object', () => {
-      expect(shouldShowLoggingAlert({})).toBe(false);
-    });
-
-    it('returns false when isTeamMember is missing', () => {
-      const metadata = { extendedLogging: true };
-      expect(shouldShowLoggingAlert(metadata)).toBe(false);
-    });
-
-    it('returns false when extendedLogging is missing', () => {
-      const metadata = { isTeamMember: true };
-      expect(shouldShowLoggingAlert(metadata)).toBe(false);
-    });
+    it.each([undefined, '', 'invalid json'])(
+      'returns false when metadata is invalid JSON and captures exception',
+      (metadata) => {
+        expect(shouldShowLoggingAlert(metadata)).toBe(false);
+        expect(Sentry.captureException).toHaveBeenCalledWith(expect.any(SyntaxError));
+      },
+    );
   });
 });
-- 
GitLab


From e1828044a8dbd8706a4989ed0b96f783e3f2db98 Mon Sep 17 00:00:00 2001
From: Tomas Bulva <tbulva@gitlab.com>
Date: Tue, 2 Sep 2025 17:37:44 +0200
Subject: [PATCH 6/8] Updated tests according to Marks review

---
 .../duo_agentic_chat/components/app_spec.js   | 151 ++++--------------
 .../ai/tanuki_bot/components/app_spec.js      |  13 +-
 ee/spec/frontend/ai/utils_spec.js             |   1 -
 3 files changed, 39 insertions(+), 126 deletions(-)

diff --git a/ee/spec/frontend/ai/duo_agentic_chat/components/app_spec.js b/ee/spec/frontend/ai/duo_agentic_chat/components/app_spec.js
index 1830dac21fdc85..d89b5376aae6d7 100644
--- a/ee/spec/frontend/ai/duo_agentic_chat/components/app_spec.js
+++ b/ee/spec/frontend/ai/duo_agentic_chat/components/app_spec.js
@@ -192,6 +192,8 @@ describe('Duo Agentic Chat', () => {
 
   const findDuoChat = () => wrapper.findComponent(AgenticDuoChat);
   const findGlToggle = () => wrapper.findComponent(GlToggle);
+  const findLoggingAlert = () => wrapper.findComponent({ name: 'DuoChatLoggingAlert' });
+
   const getLastSocketCall = () => {
     const { calls } = createWebSocket.mock;
     if (calls.length === 0) {
@@ -345,10 +347,7 @@ describe('Duo Agentic Chat', () => {
 
     it('renders DuoChatLoggingAlert when shouldShowLoggingAlert returns true', () => {
       const metadata = JSON.stringify({ is_team_member: true, extended_logging: true });
-      shouldShowLoggingAlert.mockReturnValue(true);
-
       createComponent({ propsData: { metadata } });
-
       expect(shouldShowLoggingAlert).toHaveBeenCalledWith(metadata);
     });
 
@@ -359,10 +358,10 @@ describe('Duo Agentic Chat', () => {
       createComponent({ propsData: { metadata } });
 
       expect(shouldShowLoggingAlert).toHaveBeenCalledWith(metadata);
-      expect(findDuoChat().vm.$slots.subheader).toBeUndefined();
+      expect(findLoggingAlert().exists()).toBe(false);
     });
 
-    it('renders DuoChatLoggingAlert in the subheader slot when shown', () => {
+    it('renders DuoChatLoggingAlert when shown', () => {
       shouldShowLoggingAlert.mockReturnValue(true);
       createComponent();
 
@@ -522,19 +521,6 @@ describe('Duo Agentic Chat', () => {
         expect(actionSpies.setLoading).toHaveBeenCalledWith(expect.anything(), true);
       });
 
-      it('does not create a new workflow if one already exists', async () => {
-        wrapper.vm.workflowId = '456';
-
-        findDuoChat().vm.$emit('send-chat-prompt', MOCK_USER_MESSAGE.content);
-        await waitForPromises();
-
-        expect(ApolloUtils.createWorkflow).not.toHaveBeenCalled();
-        expect(createWebSocket).toHaveBeenCalledWith(
-          '/api/v4/ai/duo_workflows/ws',
-          expect.any(Object),
-        );
-      });
-
       it('sends the correct start request to WebSocket when connected', async () => {
         createComponent({
           propsData: {
@@ -636,32 +622,6 @@ describe('Duo Agentic Chat', () => {
             mockSocketManager.connect.mockClear();
           });
 
-          it('sends all required fields according to protobuf schema', async () => {
-            contextPresetsQueryHandlerMock.mockResolvedValueOnce({
-              data: { aiChatContextPresets: { questions: [], aiResourceData: null } },
-            });
-
-            duoChatGlobalState.isAgenticChatShown = true;
-            await waitForPromises();
-
-            findDuoChat().vm.$emit('send-chat-prompt', 'test question');
-            await waitForPromises();
-
-            // for details see contract: https://gitlab.com/gitlab-org/modelops/applied-ml/code-suggestions/ai-assist/-/blob/9716e956e1e643adf64b361d9334ddfc182e2279/contract/contract.proto#L21
-            expect(mockSocketManager.connect).toHaveBeenCalledWith(
-              expect.objectContaining({
-                startRequest: expect.objectContaining({
-                  clientVersion: expect.any(String),
-                  workflowID: expect.any(String),
-                  workflowDefinition: expect.any(String),
-                  goal: expect.any(String),
-                  workflowMetadata: expect.any(String),
-                  approval: expect.any(Object),
-                }),
-              }),
-            );
-          });
-
           it('validates field types match protobuf schema', async () => {
             contextPresetsQueryHandlerMock.mockResolvedValueOnce({
               data: { aiChatContextPresets: { questions: [], aiResourceData: null } },
@@ -676,6 +636,25 @@ describe('Duo Agentic Chat', () => {
             const callArg = mockSocketManager.connect.mock.calls[0][0];
             const { startRequest } = callArg;
 
+            const allowedFields = [
+              'clientVersion',
+              'workflowID',
+              'workflowDefinition',
+              'goal',
+              'workflowMetadata',
+              'clientCapabilities',
+              'mcpTools',
+              'additionalContext',
+              'approval',
+              'flowConfig',
+              'flowConfigSchemaVersion',
+            ];
+            const actualFields = Object.keys(callArg.startRequest);
+
+            actualFields.forEach((field) => {
+              expect(allowedFields).toContain(field);
+            });
+
             expect(typeof startRequest.clientVersion).toBe('string');
             expect(typeof startRequest.workflowID).toBe('string');
             expect(typeof startRequest.workflowDefinition).toBe('string');
@@ -718,49 +697,16 @@ describe('Duo Agentic Chat', () => {
             expect(callArg.startRequest.workflowMetadata).toBe(JSON.stringify(metadata));
           });
 
-          it('handles null metadata', async () => {
-            createComponent({
-              propsData: {
-                projectId: MOCK_PROJECT_ID,
-                resourceId: MOCK_RESOURCE_ID,
-                metadata: null,
-              },
-            });
-            duoChatGlobalState.isAgenticChatShown = true;
-            await waitForPromises();
-
-            findDuoChat().vm.$emit('send-chat-prompt', 'test question');
-            await waitForPromises();
-
-            const callArg = mockSocketManager.connect.mock.calls[0][0];
-            expect(callArg.startRequest.workflowMetadata).toBe(null);
-          });
-
-          it('handles undefined metadata', async () => {
-            createComponent({
-              propsData: {
-                projectId: MOCK_PROJECT_ID,
-                resourceId: MOCK_RESOURCE_ID,
-                metadata: undefined,
-              },
-            });
-
-            duoChatGlobalState.isAgenticChatShown = true;
-            await waitForPromises();
-
-            findDuoChat().vm.$emit('send-chat-prompt', 'test question');
-            await waitForPromises();
-
-            const callArg = mockSocketManager.connect.mock.calls[0][0];
-            expect(callArg.startRequest.workflowMetadata).toBe(null);
-          });
-
-          it('handles empty object metadata', async () => {
+          it.each([
+            ['null', null, null],
+            ['undefined', undefined, null],
+            ['empty object', '{}', '{}'],
+          ])('handles %s metadata', async (description, metadataInput, expectedOutput) => {
             createComponent({
               propsData: {
                 projectId: MOCK_PROJECT_ID,
                 resourceId: MOCK_RESOURCE_ID,
-                metadata: '{}',
+                metadata: metadataInput,
               },
             });
             duoChatGlobalState.isAgenticChatShown = true;
@@ -770,7 +716,7 @@ describe('Duo Agentic Chat', () => {
             await waitForPromises();
 
             const callArg = mockSocketManager.connect.mock.calls[0][0];
-            expect(callArg.startRequest.workflowMetadata).toBe('{}');
+            expect(callArg.startRequest.workflowMetadata).toBe(expectedOutput);
           });
         });
 
@@ -876,43 +822,6 @@ describe('Duo Agentic Chat', () => {
             expect(callArg.startRequest.workflowDefinition).toBe('chat');
           });
         });
-
-        describe('protobuf schema compliance', () => {
-          beforeEach(async () => {
-            createComponent();
-            duoChatGlobalState.isAgenticChatShown = true;
-            await waitForPromises();
-          });
-
-          afterEach(() => {
-            mockSocketManager.connect.mockClear();
-          });
-
-          it('does not include fields not defined in protobuf schema', async () => {
-            findDuoChat().vm.$emit('send-chat-prompt', 'test question');
-            await waitForPromises();
-
-            const callArg = mockSocketManager.connect.mock.calls[0][0];
-            const allowedFields = [
-              'clientVersion',
-              'workflowID',
-              'workflowDefinition',
-              'goal',
-              'workflowMetadata',
-              'clientCapabilities',
-              'mcpTools',
-              'additionalContext',
-              'approval',
-              'flowConfig',
-              'flowConfigSchemaVersion',
-            ];
-            const actualFields = Object.keys(callArg.startRequest);
-
-            actualFields.forEach((field) => {
-              expect(allowedFields).toContain(field);
-            });
-          });
-        });
       });
 
       it('handles tool approval flow', async () => {
diff --git a/ee/spec/frontend/ai/tanuki_bot/components/app_spec.js b/ee/spec/frontend/ai/tanuki_bot/components/app_spec.js
index 39af7fa94463ce..17127eb5cc5f9f 100644
--- a/ee/spec/frontend/ai/tanuki_bot/components/app_spec.js
+++ b/ee/spec/frontend/ai/tanuki_bot/components/app_spec.js
@@ -302,9 +302,10 @@ describeSkipVue3(skipReason, () => {
       shouldShowLoggingAlert.mockReturnValue(true);
     });
 
-    it('renders DuoChatLoggingAlert when shouldShowLoggingAlert returns true', () => {
+    it('renders DuoChatLoggingAlert when shouldShowLoggingAlert returns true', async () => {
       const metadata = JSON.stringify({ is_team_member: true, extended_logging: true });
       shouldShowLoggingAlert.mockReturnValue(true);
+      getCookie.mockReturnValue('false');
 
       createComponent({
         propsData: {
@@ -314,8 +315,12 @@ describeSkipVue3(skipReason, () => {
         },
       });
 
+      // two nextTicks are nescessary
+      await nextTick();
+      await nextTick();
+
       expect(shouldShowLoggingAlert).toHaveBeenCalledWith(metadata);
-      expect(wrapper.vm.shouldShowLoggingAlert).toBe(true);
+      expect(findLoggingAlert().exists()).toBe(true);
     });
 
     it('does not render DuoChatLoggingAlert when shouldShowLoggingAlert returns false', () => {
@@ -331,14 +336,14 @@ describeSkipVue3(skipReason, () => {
       });
 
       expect(shouldShowLoggingAlert).toHaveBeenCalledWith(metadata);
-      expect(wrapper.vm.shouldShowLoggingAlert).toBe(false);
+      expect(findLoggingAlert().exists()).toBe(false);
     });
 
     it('renders DuoChatLoggingAlert in the subheader slot when shown', () => {
       shouldShowLoggingAlert.mockReturnValue(true);
       createComponent();
 
-      expect(wrapper.vm.shouldShowLoggingAlert).toBe(true);
+      expect(findLoggingAlert().exists()).toBe(true);
     });
 
     it('does not render DuoChatLoggingAlert when Duo Chat is not shown', () => {
diff --git a/ee/spec/frontend/ai/utils_spec.js b/ee/spec/frontend/ai/utils_spec.js
index 39fe5f157b9f8c..bc219b8ae57b80 100644
--- a/ee/spec/frontend/ai/utils_spec.js
+++ b/ee/spec/frontend/ai/utils_spec.js
@@ -382,7 +382,6 @@ describe('AI Utils', () => {
 
     it('returns false when metadata is null', () => {
       // `null` stringifies to `"null"`, which then parses back to `null`, so no error is thrown.
-      // TODO: Is this acceptable?
       expect(shouldShowLoggingAlert(null)).toBe(false);
       expect(Sentry.captureException).not.toHaveBeenCalled();
     });
-- 
GitLab


From cab00aee2309d466900f537165854cc0a354d67b Mon Sep 17 00:00:00 2001
From: Tomas Bulva <tbulva@gitlab.com>
Date: Wed, 3 Sep 2025 15:00:08 +0200
Subject: [PATCH 7/8] Modified tests

---
 .../duo_agentic_chat/components/app_spec.js   | 30 +++----------------
 1 file changed, 4 insertions(+), 26 deletions(-)

diff --git a/ee/spec/frontend/ai/duo_agentic_chat/components/app_spec.js b/ee/spec/frontend/ai/duo_agentic_chat/components/app_spec.js
index d89b5376aae6d7..4817ae80939c69 100644
--- a/ee/spec/frontend/ai/duo_agentic_chat/components/app_spec.js
+++ b/ee/spec/frontend/ai/duo_agentic_chat/components/app_spec.js
@@ -342,38 +342,19 @@ describe('Duo Agentic Chat', () => {
   describe('DuoChatLoggingAlert Integration', () => {
     beforeEach(() => {
       duoChatGlobalState.isAgenticChatShown = true;
-      shouldShowLoggingAlert.mockReturnValue(true);
-    });
-
-    it('renders DuoChatLoggingAlert when shouldShowLoggingAlert returns true', () => {
-      const metadata = JSON.stringify({ is_team_member: true, extended_logging: true });
-      createComponent({ propsData: { metadata } });
-      expect(shouldShowLoggingAlert).toHaveBeenCalledWith(metadata);
     });
 
     it('does not render DuoChatLoggingAlert when shouldShowLoggingAlert returns false', () => {
+      const originalUtils = jest.requireActual('ee/ai/utils');
+      shouldShowLoggingAlert.mockImplementation(originalUtils.shouldShowLoggingAlert);
+
       const metadata = JSON.stringify({ is_team_member: false, extended_logging: false });
-      shouldShowLoggingAlert.mockReturnValue(false);
 
       createComponent({ propsData: { metadata } });
 
       expect(shouldShowLoggingAlert).toHaveBeenCalledWith(metadata);
       expect(findLoggingAlert().exists()).toBe(false);
     });
-
-    it('renders DuoChatLoggingAlert when shown', () => {
-      shouldShowLoggingAlert.mockReturnValue(true);
-      createComponent();
-
-      expect(wrapper.vm.shouldShowLoggingAlert).toBe(true);
-    });
-
-    it('does not render DuoChatLoggingAlert when Duo Chat is not shown', () => {
-      duoChatGlobalState.isAgenticChatShown = false;
-      createComponent();
-
-      expect(findDuoChat().exists()).toBe(false);
-    });
   });
 
   describe('events handling', () => {
@@ -661,10 +642,7 @@ describe('Duo Agentic Chat', () => {
             expect(typeof startRequest.goal).toBe('string');
             expect(typeof startRequest.workflowMetadata).toBe('string');
             expect(typeof startRequest.approval).toBe('object');
-
-            if (startRequest.additionalContext) {
-              expect(Array.isArray(startRequest.additionalContext)).toBe(true);
-            }
+            expect(Array.isArray(startRequest.additionalContext)).toBe(true);
           });
         });
 
-- 
GitLab


From 7ca32ab7fb7914e720d3a817ae79f271dd8dd434 Mon Sep 17 00:00:00 2001
From: Tomas Bulva <tbulva@gitlab.com>
Date: Thu, 11 Sep 2025 13:14:20 +0200
Subject: [PATCH 8/8] Rebase fix

---
 .../assets/javascripts/ai/duo_agentic_chat/components/app.vue   | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/ee/app/assets/javascripts/ai/duo_agentic_chat/components/app.vue b/ee/app/assets/javascripts/ai/duo_agentic_chat/components/app.vue
index d4490ba2662350..67d1fbada2008d 100644
--- a/ee/app/assets/javascripts/ai/duo_agentic_chat/components/app.vue
+++ b/ee/app/assets/javascripts/ai/duo_agentic_chat/components/app.vue
@@ -8,7 +8,7 @@ import { renderGFM } from '~/behaviors/markdown/render_gfm';
 import { getCookie } from '~/lib/utils/common_utils';
 import { getStorageValue, saveStorageValue } from '~/lib/utils/local_storage';
 import { duoChatGlobalState } from '~/super_sidebar/constants';
-import { clearDuoChatCommands, setAgenticMode } from 'ee/ai/utils';
+import { clearDuoChatCommands, setAgenticMode, shouldShowLoggingAlert } from 'ee/ai/utils';
 import { parseGid, convertToGraphQLId } from '~/graphql_shared/utils';
 import { TYPENAME_AI_DUO_WORKFLOW } from '~/graphql_shared/constants';
 import {
-- 
GitLab