@camunda/e2e-test-suite 0.0.1458 → 0.0.1460

package/dist/pages/8.10/OperateProcessInstancePage.d.ts

@@ -17,6 +17,10 @@ declare class OperateProcessInstancePage {
     readonly messageVariable: Locator;
     readonly whatsNewPopUp: Locator;
     readonly gotItButton: Locator;
+    readonly detailsTab: Locator;
+    readonly agentInstancePanel: Locator;
+    readonly conversationHistorySection: Locator;
+    readonly conversationHistoryTrigger: Locator;
     constructor(page: Page);
     connectorResultVariableValue(variableName: string): Promise<Locator>;
     rememberInstanceUrl(timeout?: number, watchedUrl?: InstanceUrlWatcher): Promise<void>;
@@ -36,6 +40,10 @@ declare class OperateProcessInstancePage {
     assertProcessVariableContainsText(variableName: string, text: string): Promise<void>;
     assertProcessVariableHasDocumentCount(variableName: string, count: number, softFail?: boolean): Promise<void>;
     clickDiagramTask(taskName: string): Promise<void>;
+    openAgentConversation(elementId: string): Promise<void>;
+    assertReadableReasoning(reasoningHistoryItemKey: string, answerHistoryItemKey: string): Promise<void>;
+    assertEncryptedReasoningIsHidden(reasoningHistoryItemKey: string, answerHistoryItemKey: string): Promise<void>;
+    private assertFinalAnswerVisible;
     assertActiveTokenIsPresent(): Promise<void>;
     assertDetailsPopoverIsVisible(): Promise<void>;
     assertBusinessIdVisible(businessId: string): Promise<void>;

package/dist/pages/8.10/OperateProcessInstancePage.js

@@ -158,6 +158,10 @@ class OperateProcessInstancePage {
     messageVariable;
     whatsNewPopUp;
     gotItButton;
+    detailsTab;
+    agentInstancePanel;
+    conversationHistorySection;
+    conversationHistoryTrigger;
     constructor(page) {
         this.page = page;
         this.diagram = page.getByTestId('diagram');
@@ -185,6 +189,16 @@ class OperateProcessInstancePage {
             name: "Here's what moved in Operate",
         });
         this.gotItButton = page.getByRole('button', { name: 'Got it' });
+        this.detailsTab = page
+            .getByLabel('Process Instance Bottom Panel Tabs')
+            .getByRole('link', { name: 'Details' });
+        this.agentInstancePanel = page.getByRole('article', {
+            name: 'Agent Instance',
+        });
+        this.conversationHistorySection = this.agentInstancePanel.getByTestId('agent-conversation-history-section');
+        this.conversationHistoryTrigger = this.conversationHistorySection.getByRole('button', {
+            name: 'Conversation history',
+        });
     }
     async connectorResultVariableValue(variableName) {
         return await this.page.getByTestId(variableName).locator('td').last();
@@ -874,6 +888,48 @@ class OperateProcessInstancePage {
         await (0, test_1.expect)(diagramTask).toBeVisible();
         await diagramTask.click();
     }
+    async openAgentConversation(elementId) {
+        const agentTask = this.diagram.locator(`.djs-element[data-element-id="${elementId}"]`);
+        // BpmnJS ignores element clicks until element statistics load and the
+        // element receives the op-selectable marker.
+        await (0, test_1.expect)(agentTask).toHaveClass(/op-selectable/, { timeout: 30000 });
+        await agentTask.click();
+        await (0, test_1.expect)(this.detailsTab).toBeVisible();
+        await this.detailsTab.click();
+        await (0, test_1.expect)(this.agentInstancePanel).toBeVisible({ timeout: 30000 });
+        await (0, test_1.expect)(this.conversationHistoryTrigger).toHaveAttribute('aria-expanded', 'false');
+        await this.conversationHistoryTrigger.click();
+        await (0, test_1.expect)(this.conversationHistoryTrigger).toHaveAttribute('aria-expanded', 'true');
+    }
+    async assertReadableReasoning(reasoningHistoryItemKey, answerHistoryItemKey) {
+        const reasoningMessage = this.conversationHistorySection.getByTestId(`conversation-message-${reasoningHistoryItemKey}`);
+        const thinkingRegion = reasoningMessage.getByRole('region', {
+            name: 'Thinking',
+        });
+        const answerMessage = this.conversationHistorySection.getByTestId(`conversation-message-${answerHistoryItemKey}`);
+        await (0, test_1.expect)(reasoningMessage).toHaveAttribute('aria-label', 'Assistant message', { timeout: 60000 });
+        await (0, test_1.expect)(thinkingRegion).toBeVisible();
+        await (0, test_1.expect)(thinkingRegion.locator('p')).toHaveText(/\S/);
+        await (0, test_1.expect)(thinkingRegion.getByRole('button')).toHaveCount(0);
+        await this.assertFinalAnswerVisible(answerMessage);
+        await (0, test_1.expect)(this.conversationHistorySection).not.toContainText(/camunda\.agenticai\.content\.type|encrypted_content|signature|"payload"/);
+    }
+    async assertEncryptedReasoningIsHidden(reasoningHistoryItemKey, answerHistoryItemKey) {
+        const reasoningMessage = this.conversationHistorySection.getByTestId(`conversation-message-${reasoningHistoryItemKey}`);
+        const answerMessage = this.conversationHistorySection.getByTestId(`conversation-message-${answerHistoryItemKey}`);
+        await (0, test_1.expect)(reasoningMessage).toHaveAttribute('aria-label', 'Assistant message', { timeout: 60000 });
+        await (0, test_1.expect)(reasoningMessage).toBeVisible({ timeout: 60000 });
+        await (0, test_1.expect)(reasoningMessage.getByRole('region', { name: 'Thinking' })).toHaveCount(0);
+        await (0, test_1.expect)(this.conversationHistorySection).not.toContainText(/encrypted_content|camunda\.agenticai\.content\.type|"payload"|signature/);
+        await this.assertFinalAnswerVisible(answerMessage);
+    }
+    async assertFinalAnswerVisible(answerMessage) {
+        await (0, test_1.expect)(answerMessage).toHaveAttribute('aria-label', 'Assistant message', { timeout: 60000 });
+        // The Thinking note is a <section> named via aria-labelledby, so match
+        // only answer text that is not nested inside it.
+        const answerOutsideThinking = answerMessage.locator('xpath=.//*[text()[contains(., "Answer:")]][not(ancestor::section[@aria-labelledby = //*[normalize-space(text())="Thinking"]/@id])]');
+        await (0, test_1.expect)(answerOutsideThinking.first()).toBeVisible({ timeout: 60000 });
+    }
     async assertActiveTokenIsPresent() {
         await (0, test_1.expect)(this.activeIcon).toBeVisible({ timeout: 60000 });
     }

package/dist/pages/8.8/TaskPanelPage.d.ts

@@ -10,6 +10,7 @@ declare class TaskPanelPage {
     readonly expandButton: Locator;
     readonly processesInfoText: Locator;
     constructor(page: Page);
+    waitForTasklistLoaded(timeout?: number): Promise<void>;
     openTask(name: string, taskKeys?: string[]): Promise<void>;
     filterBy(option: 'All open' | 'Unassigned' | 'Assigned to me' | 'Completed'): Promise<void>;
     taskCount(name: string): Promise<number>;

package/dist/pages/8.8/TaskPanelPage.js

@@ -30,6 +30,27 @@ class TaskPanelPage {
         });
         this.processesInfoText = page.getByText('Browse and run processes published by your organization');
     }
+    // Tasklist renders its route error page ("Something went wrong") when its
+    // lazily loaded JS chunks 404 -- seen on the AWS cluster when index.html
+    // and the asset chunks came from different builds. A reload fetches a
+    // consistent shell + chunks; the banner assertion itself is unchanged.
+    async waitForTasklistLoaded(timeout = 120000) {
+        const errorPage = this.page.getByRole('heading', {
+            name: 'Something went wrong',
+        });
+        const maxReloads = 3;
+        for (let attempt = 1; attempt <= maxReloads; attempt++) {
+            await (0, test_1.expect)(this.taskListPageBanner.or(errorPage).first()).toBeVisible({
+                timeout,
+            });
+            if (await this.taskListPageBanner.isVisible()) {
+                return;
+            }
+            console.warn(`Tasklist failed to load (attempt ${attempt}/${maxReloads}), reloading`);
+            await this.page.reload();
+        }
+        await (0, test_1.expect)(this.taskListPageBanner).toBeVisible({ timeout });
+    }
     async openTask(name, taskKeys) {
         let attempts = 0;
         // Tasklist's importer can lag well behind Zeebe under heavy concurrent

package/dist/tests/8.10/agentic-ai-user-flows.spec.js

@@ -4,6 +4,7 @@ const _8_10_1 = require("../../fixtures/8.10");
 const UtilitiesPage_1 = require("../../pages/8.10/UtilitiesPage");
 const _setup_1 = require("../../test-setup.js");
 const apiHelpers_1 = require("../../utils/apiHelpers");
+const agentInstanceHistoryHelpers_1 = require("../../utils/agentInstanceHistoryHelpers");
 const sleep_1 = require("../../utils/sleep");
 const users_1 = require("../../utils/users");
 const testUser = (0, users_1.getTestUser)('fourteenthUser');
@@ -62,6 +63,21 @@ const aiAgentSubProcessTestCases = [
         bpmnPath: './resources/agentic_ai/ai-agent-subprocess-with-tools_aws_key.bpmn',
     },
 ];
+const agentReasoningTestCases = [
+    {
+        name: 'Readable reasoning appears in Operate',
+        bpmnPath: './resources/agentic_ai/ai-agent-chat-with-tools_anthropic_bedrock_apikey.bpmn',
+        provider: 'anthropic-adaptive',
+        reasoningMode: 'readable',
+    },
+    {
+        name: 'Encrypted reasoning stays hidden in Operate',
+        bpmnPath: './resources/agentic_ai/ai-agent-chat-with-tools_open_ai.bpmn',
+        provider: 'openai-encrypted',
+        reasoningMode: 'encrypted-only',
+    },
+];
+const agentReasoningResources = new Map();
 const regexTestCases = [
     {
         regex_ai_agent_time: /The current date and time in ([A-Za-zÀ-ÿ .,'-]+(?:, [A-Za-zÀ-ÿ .,'-]+)*), is approximately ((?:0?[1-9]|1[0-2]):[0-5][0-9] (?:AM|PM)) on ([A-Z][a-z]+ (?:[1-9]|[12][0-9]|3[01]), \d{4})\./,
@@ -205,4 +221,75 @@ _8_10_1.test.describe('Agentic Orchestation User Flows', () => {
             });
         }
     });
+    _8_10_1.test.describe('AI Agent reasoning in Operate', () => {
+        // Playwright requires destructured fixture arguments.
+        // eslint-disable-next-line no-empty-pattern
+        _8_10_1.test.afterEach(async ({}, testInfo) => {
+            const resources = agentReasoningResources.get(testInfo.testId);
+            if (!resources) {
+                return;
+            }
+            const cleanupErrors = await (0, agentInstanceHistoryHelpers_1.cleanupAgentReasoningResources)(resources.processInstanceKey, resources.processDefinitionKey, authToken);
+            agentReasoningResources.delete(testInfo.testId);
+            if (cleanupErrors.length === 1) {
+                throw cleanupErrors[0];
+            }
+            if (cleanupErrors.length > 1) {
+                throw new AggregateError(cleanupErrors, 'Agent reasoning resource cleanup failed');
+            }
+        });
+        for (const params of agentReasoningTestCases) {
+            (0, _8_10_1.test)(params.name, async ({ appsPage, operateHomePage, operateProcessInstancePage, operateProcessesPage, taskPanelPage, taskDetailsPage, }, testInfo) => {
+                _8_10_1.test.slow();
+                const suffix = await (0, _setup_1.generateRandomStringAsync)(6);
+                const processId = `ai-agent-reasoning-${params.provider}-${suffix.toLowerCase()}`;
+                const processName = `AI Agent ${params.name} ${suffix}`;
+                const resources = {};
+                agentReasoningResources.set(testInfo.testId, resources);
+                const processDefinitionKey = await (0, agentInstanceHistoryHelpers_1.deployAgentReasoningProcess)(params.bpmnPath, authToken, processId, processName, params.provider);
+                resources.processDefinitionKey = processDefinitionKey;
+                const processInstanceKey = await (0, apiHelpers_1.createProcessInstance)(processDefinitionKey, authToken);
+                resources.processInstanceKey = processInstanceKey;
+                await _8_10_1.test.step('Wait for the agent feedback task and committed history', async () => {
+                    await appsPage.clickCamundaApps();
+                    await appsPage.clickTasklist(clusterName);
+                    await taskPanelPage.openTask(processName);
+                    await taskDetailsPage.clickAssignToMeButton();
+                    await taskDetailsPage.assertAIResponse(/Answer:/);
+                });
+                const historyKeys = await (0, agentInstanceHistoryHelpers_1.waitForAgentReasoningHistory)(processInstanceKey, authToken, params.reasoningMode);
+                await _8_10_1.test.step('Verify the conversation in Operate', async () => {
+                    await appsPage.clickCamundaApps();
+                    await appsPage.clickOperate(clusterName);
+                    await operateHomePage.clickProcessesTab();
+                    await operateProcessesPage.applyMoreFilters('Process Instance Key(s)', processInstanceKey);
+                    await operateProcessesPage.clickProcessInstanceLink(processName);
+                    await operateProcessInstancePage.closePopOverIfVisible();
+                    await operateProcessInstancePage.assertActiveTokenIsPresent();
+                    await operateProcessInstancePage.openAgentConversation('AI_Agent');
+                    if (params.reasoningMode === 'readable') {
+                        await operateProcessInstancePage.assertReadableReasoning(historyKeys.reasoningHistoryItemKey, historyKeys.answerHistoryItemKey);
+                    }
+                    else {
+                        await operateProcessInstancePage.assertEncryptedReasoningIsHidden(historyKeys.reasoningHistoryItemKey, historyKeys.answerHistoryItemKey);
+                    }
+                });
+                await _8_10_1.test.step('Complete the feedback task and finish the process', async () => {
+                    await appsPage.clickCamundaApps();
+                    await appsPage.clickTasklist(clusterName);
+                    await taskPanelPage.openTask(processName);
+                    await taskDetailsPage.checkChecklistBox('Are you satisfied with the result?');
+                    await taskDetailsPage.clickCompleteTaskButton();
+                    await appsPage.clickCamundaApps();
+                    await appsPage.clickOperate(clusterName);
+                    await operateHomePage.clickProcessesTab();
+                    await operateProcessesPage.clickProcessCompletedCheckbox();
+                    await operateProcessesPage.applyMoreFilters('Process Instance Key(s)', processInstanceKey);
+                    await operateProcessesPage.clickProcessInstanceLink(processName);
+                    await operateProcessInstancePage.assertProcessCompleteStatusWithRetry();
+                    resources.processInstanceKey = undefined;
+                });
+            });
+        }
+    });
 });

package/dist/tests/8.8/aws-cluster-user-flows.spec.js

@@ -94,9 +94,7 @@ _8_8_1.test.describe('AWS Cluster User Flows Test', () => {
         await _8_8_1.test.step('Navigate to Tasklist and Assert Document Upload And Preview', async () => {
             await appsPage.clickCamundaApps();
             await appsPage.clickTasklist(clusterName);
-            await (0, test_1.expect)(taskPanelPage.taskListPageBanner).toBeVisible({
-                timeout: 120000,
-            });
+            await taskPanelPage.waitForTasklistLoaded();
             await taskPanelPage.openTask(processName);
             await taskDetailsPage.clickAssignToMeButton();
             await (0, fileUpload_1.uploadFile)(page, [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camunda/e2e-test-suite",
-  "version": "0.0.1458",
+  "version": "0.0.1460",
   "description": "End-to-end test helpers for Camunda 8",
   "repository": {
     "type": "git",