@camunda/e2e-test-suite 0.0.1455 → 0.0.1457

package/dist/pages/8.11/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.11/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/tests/8.11/agentic-ai-user-flows.spec.js

@@ -4,6 +4,7 @@ const _8_11_1 = require("../../fixtures/8.11");
 const UtilitiesPage_1 = require("../../pages/8.11/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})\./,
@@ -206,4 +222,75 @@ _8_11_1.test.describe('Agentic Orchestation User Flows', () => {
             });
         }
     });
+    _8_11_1.test.describe('AI Agent reasoning in Operate', () => {
+        // Playwright requires destructured fixture arguments.
+        // eslint-disable-next-line no-empty-pattern
+        _8_11_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_11_1.test)(params.name, async ({ appsPage, operateHomePage, operateProcessInstancePage, operateProcessesPage, taskPanelPage, taskDetailsPage, }, testInfo) => {
+                _8_11_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_11_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_11_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_11_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/utils/agentInstanceHistoryHelpers.d.ts

@@ -0,0 +1,11 @@
+import { type AgentReasoningProvider } from './agentReasoningBpmnFixtures';
+export type AgentReasoningHistoryKeys = {
+    agentInstanceKey: string;
+    answerHistoryItemKey: string;
+    reasoningHistoryItemKey: string;
+};
+export type { AgentReasoningProvider } from './agentReasoningBpmnFixtures';
+export declare function deployAgentReasoningProcess(bpmnPath: string, authToken: string, processId: string, processName: string, provider: AgentReasoningProvider): Promise<string>;
+export declare function cancelAgentReasoningProcessInstance(processInstanceKey: string, authToken: string): Promise<void>;
+export declare function cleanupAgentReasoningResources(processInstanceKey: string | undefined, processDefinitionKey: string | undefined, authToken: string): Promise<unknown[]>;
+export declare function waitForAgentReasoningHistory(processInstanceKey: string, authToken: string, reasoningMode: 'readable' | 'encrypted-only'): Promise<AgentReasoningHistoryKeys>;

package/dist/utils/agentInstanceHistoryHelpers.js

@@ -0,0 +1,229 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitForAgentReasoningHistory = exports.cleanupAgentReasoningResources = exports.cancelAgentReasoningProcessInstance = exports.deployAgentReasoningProcess = void 0;
+const test_1 = require("@playwright/test");
+const agentReasoningBpmnFixtures_1 = require("./agentReasoningBpmnFixtures");
+const apiHelpers_1 = require("./apiHelpers");
+const REASONING_TYPE = 'camunda.agenticai.content.type';
+const FINAL_ANSWER_MARKER = 'Answer:';
+async function deployAgentReasoningProcess(bpmnPath, authToken, processId, processName, provider) {
+    const bpmn = (0, agentReasoningBpmnFixtures_1.buildAgentReasoningBpmn)(bpmnPath, processId, processName, provider);
+    const request = await (0, apiHelpers_1.getApiRequestContext)();
+    const multipart = {
+        resources: {
+            name: `${processId}.bpmn`,
+            mimeType: 'application/vnd.bpmn+xml',
+            buffer: Buffer.from(bpmn),
+        },
+    };
+    if (process.env.IS_MT === 'true') {
+        multipart.tenantId = '<default>';
+    }
+    const response = await request.post((0, apiHelpers_1.buildZeebeApiUrl)('/v2/deployments'), {
+        headers: { Authorization: authToken },
+        multipart,
+    });
+    (0, test_1.expect)(response.status(), `Reasoning process deployment failed for ${processName}`).toBe(200);
+    const body = (await response.json());
+    const processDefinitionKey = body.deployments?.[0]?.processDefinition?.processDefinitionKey;
+    if (processDefinitionKey === undefined || processDefinitionKey === null) {
+        throw new Error(`Reasoning process deployment returned no process definition key for ${processName}`);
+    }
+    return String(processDefinitionKey);
+}
+exports.deployAgentReasoningProcess = deployAgentReasoningProcess;
+async function cancelAgentReasoningProcessInstance(processInstanceKey, authToken) {
+    const request = await (0, apiHelpers_1.getApiRequestContext)();
+    const response = await request.post((0, apiHelpers_1.buildZeebeApiUrl)(`/v2/process-instances/${encodeURIComponent(processInstanceKey)}/cancellation`), {
+        headers: { Authorization: authToken },
+        data: {},
+    });
+    (0, test_1.expect)([204, 409], `Cleanup cancellation failed for process instance ${processInstanceKey}`).toContain(response.status());
+}
+exports.cancelAgentReasoningProcessInstance = cancelAgentReasoningProcessInstance;
+async function deleteAgentReasoningProcessDefinition(processDefinitionKey, authToken) {
+    const request = await (0, apiHelpers_1.getApiRequestContext)();
+    const response = await request.post((0, apiHelpers_1.buildZeebeApiUrl)(`/v2/resources/${encodeURIComponent(processDefinitionKey)}/deletion`), {
+        headers: { Authorization: authToken },
+        data: {},
+    });
+    (0, test_1.expect)(response.status(), `Cleanup deletion failed for process definition ${processDefinitionKey}`).toBe(200);
+}
+async function cleanupAgentReasoningResources(processInstanceKey, processDefinitionKey, authToken) {
+    const cleanupErrors = [];
+    if (processInstanceKey !== undefined) {
+        try {
+            await cancelAgentReasoningProcessInstance(processInstanceKey, authToken);
+        }
+        catch (error) {
+            cleanupErrors.push(error);
+        }
+    }
+    if (processDefinitionKey !== undefined) {
+        try {
+            await deleteAgentReasoningProcessDefinition(processDefinitionKey, authToken);
+        }
+        catch (error) {
+            cleanupErrors.push(error);
+        }
+    }
+    return cleanupErrors;
+}
+exports.cleanupAgentReasoningResources = cleanupAgentReasoningResources;
+function isPlainObject(value) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+        return false;
+    }
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}
+function summarizeAgentInstances(instances) {
+    if (instances.length === 0) {
+        return '[]';
+    }
+    return JSON.stringify(instances.map((instance) => ({
+        agentInstanceKey: instance.agentInstanceKey,
+        elementId: typeof instance.elementId === 'string' ? instance.elementId : undefined,
+        processInstanceKey: instance.processInstanceKey,
+    })));
+}
+function getReasoningObjects(item) {
+    return (item.content ?? [])
+        .filter((content) => content.contentType === 'OBJECT')
+        .map((content) => content.object)
+        .filter((object) => isPlainObject(object) && object[REASONING_TYPE] === 'reasoning');
+}
+function hasReadableReasoning(item) {
+    return getReasoningObjects(item).some((object) => typeof object.text === 'string' && object.text.trim().length > 0);
+}
+function hasEncryptedReasoningWithoutReadableText(item) {
+    const reasoningObjects = getReasoningObjects(item);
+    return (reasoningObjects.some((object) => {
+        const payload = object.payload;
+        const hasEncryptedPayload = isPlainObject(payload) &&
+            typeof payload.encrypted_content === 'string' &&
+            payload.encrypted_content.length > 0;
+        const hasReadableText = typeof object.text === 'string' && object.text.trim().length > 0;
+        return hasEncryptedPayload && !hasReadableText;
+    }) &&
+        !reasoningObjects.some((object) => typeof object.text === 'string' && object.text.trim().length > 0));
+}
+function hasFinalAnswer(item) {
+    return (item.content ?? []).some((content) => content.contentType === 'TEXT' &&
+        typeof content.text === 'string' &&
+        content.text.includes(FINAL_ANSWER_MARKER));
+}
+function isCommittedAssistantItem(item) {
+    return item.role === 'ASSISTANT' && item.commitStatus === 'COMMITTED';
+}
+async function searchAgentInstances(processInstanceKey, authToken) {
+    const request = await (0, apiHelpers_1.getApiRequestContext)();
+    const response = await (0, apiHelpers_1.retryOnTransientApiError)(async () => {
+        const result = await request.post((0, apiHelpers_1.buildZeebeApiUrl)('/v2/agent-instances/search'), {
+            headers: { Authorization: authToken },
+            data: { filter: { processInstanceKey } },
+        });
+        (0, test_1.expect)(result.status(), `Agent instance search failed for process instance ${processInstanceKey}`).toBe(200);
+        return result;
+    }, `Agent instance search for process instance ${processInstanceKey}`);
+    const body = (await response.json());
+    if (!Array.isArray(body.items)) {
+        throw new Error(`Agent instance search returned no item list for process instance ${processInstanceKey}`);
+    }
+    return body.items;
+}
+async function searchCommittedHistory(agentInstanceKey, authToken) {
+    const request = await (0, apiHelpers_1.getApiRequestContext)();
+    const response = await (0, apiHelpers_1.retryOnTransientApiError)(async () => {
+        const result = await request.post((0, apiHelpers_1.buildZeebeApiUrl)(`/v2/agent-instances/${encodeURIComponent(agentInstanceKey)}/history/search`), {
+            headers: { Authorization: authToken },
+            data: {
+                filter: { commitStatus: 'COMMITTED' },
+                sort: [{ field: 'producedAt', order: 'ASC' }],
+            },
+        });
+        if (result.status() !== 404) {
+            (0, test_1.expect)(result.status(), `Committed agent history search failed for agent instance ${agentInstanceKey}`).toBe(200);
+        }
+        return result;
+    }, `Committed agent history search for agent instance ${agentInstanceKey}`);
+    if (response.status() === 404) {
+        return [];
+    }
+    const body = (await response.json());
+    if (!Array.isArray(body.items)) {
+        throw new Error(`Committed agent history search returned no item list for agent instance ${agentInstanceKey}`);
+    }
+    return body.items;
+}
+async function waitForAgentReasoningHistory(processInstanceKey, authToken, reasoningMode) {
+    let agentInstance;
+    const findMatchingAgentInstance = (instances) => {
+        agentInstance = instances.find((instance) => instance.processInstanceKey === processInstanceKey &&
+            instance.elementId === 'AI_Agent' &&
+            typeof instance.agentInstanceKey === 'string' &&
+            instance.agentInstanceKey.length > 0);
+        return agentInstance !== undefined;
+    };
+    let instances = await searchAgentInstances(processInstanceKey, authToken);
+    if (!findMatchingAgentInstance(instances)) {
+        try {
+            await test_1.expect
+                .poll(async () => {
+                instances = await searchAgentInstances(processInstanceKey, authToken);
+                return findMatchingAgentInstance(instances);
+            }, {
+                timeout: 120000,
+                intervals: [1000, 2000, 5000],
+                message: `No AI Agent instance appeared for process instance ${processInstanceKey}`,
+            })
+                .toBe(true);
+        }
+        catch (error) {
+            const detailsError = new Error(`No AI Agent instance appeared for process instance ${processInstanceKey}. Last search response: ${summarizeAgentInstances(instances)}`);
+            Object.assign(detailsError, { cause: error });
+            throw detailsError;
+        }
+    }
+    if (agentInstance === undefined ||
+        typeof agentInstance.agentInstanceKey !== 'string') {
+        throw new Error(`AI Agent instance was not resolved for process instance ${processInstanceKey}`);
+    }
+    const agentInstanceKey = agentInstance.agentInstanceKey;
+    let reasoningItem;
+    let answerItem;
+    const findCommittedEvidence = (history) => {
+        const assistantItems = history.filter(isCommittedAssistantItem);
+        reasoningItem = assistantItems.find((item) => reasoningMode === 'readable'
+            ? hasReadableReasoning(item)
+            : hasEncryptedReasoningWithoutReadableText(item));
+        answerItem = assistantItems.find(hasFinalAnswer);
+        return (typeof reasoningItem?.historyItemKey === 'string' &&
+            typeof answerItem?.historyItemKey === 'string');
+    };
+    let history = await searchCommittedHistory(agentInstanceKey, authToken);
+    if (!findCommittedEvidence(history)) {
+        await test_1.expect
+            .poll(async () => {
+            history = await searchCommittedHistory(agentInstanceKey, authToken);
+            return findCommittedEvidence(history);
+        }, {
+            timeout: 180000,
+            intervals: [1000, 2000, 5000],
+            message: reasoningMode === 'readable'
+                ? `Committed readable reasoning and final-answer history did not appear for agent instance ${agentInstanceKey}`
+                : `Committed encrypted-only reasoning and final-answer history did not appear for agent instance ${agentInstanceKey}`,
+        })
+            .toBe(true);
+    }
+    if (typeof reasoningItem?.historyItemKey !== 'string' ||
+        typeof answerItem?.historyItemKey !== 'string') {
+        throw new Error(`Committed reasoning evidence was not resolved for agent instance ${agentInstanceKey}`);
+    }
+    return {
+        agentInstanceKey,
+        reasoningHistoryItemKey: reasoningItem.historyItemKey,
+        answerHistoryItemKey: answerItem.historyItemKey,
+    };
+}
+exports.waitForAgentReasoningHistory = waitForAgentReasoningHistory;

package/dist/utils/agentReasoningBpmnFixtures.d.ts

@@ -0,0 +1,2 @@
+export type AgentReasoningProvider = 'anthropic-adaptive' | 'openai-encrypted';
+export declare function buildAgentReasoningBpmn(bpmnPath: string, processId: string, processName: string, provider: AgentReasoningProvider): string;

package/dist/utils/agentReasoningBpmnFixtures.js

@@ -0,0 +1,130 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildAgentReasoningBpmn = void 0;
+const fs_1 = __importDefault(require("fs"));
+const REASONING_SYSTEM_PROMPT = 'Solve the quantitative problem carefully before answering. Use the supplied ' +
+    'facts and verify the result with an equation. Return a concise explanation ' +
+    'and start the final response with "Answer:".';
+const REASONING_USER_PROMPT = '="A box contains red and blue marbles. There are 20 more red marbles than ' +
+    'blue marbles. After removing 4 red marbles and adding 2 blue marbles, there ' +
+    'are twice as many red marbles as blue marbles. How many of each color were ' +
+    'in the box originally? Include a short equation that verifies your answer."';
+function escapeXml(value) {
+    return value
+        .replace(/&/g, '&')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&apos;');
+}
+function replaceXmlAttribute(element, name, value) {
+    const attribute = new RegExp(`\\b${name}="[^"]*"`);
+    if (!attribute.test(element)) {
+        throw new Error(`The BPMN process tag has no ${name} attribute`);
+    }
+    return element.replace(attribute, `${name}="${escapeXml(value)}"`);
+}
+function replaceProcessIdentity(bpmn, processId, processName) {
+    const processTag = bpmn.match(/<bpmn:process\b[^>]*>/)?.[0];
+    if (!processTag) {
+        throw new Error('The BPMN fixture has no bpmn:process element');
+    }
+    const originalProcessId = processTag.match(/\bid="([^"]*)"/)?.[1];
+    if (!originalProcessId) {
+        throw new Error('The BPMN process element has no id');
+    }
+    const updatedTag = replaceXmlAttribute(replaceXmlAttribute(processTag, 'id', processId), 'name', processName);
+    return bpmn
+        .replace(processTag, updatedTag)
+        .split(`bpmnElement="${originalProcessId}"`)
+        .join(`bpmnElement="${processId}"`);
+}
+function getAgentTask(bpmn) {
+    const agentTask = bpmn.match(/<bpmn:serviceTask\b[^>]*\bid="AI_Agent"[\s\S]*?<\/bpmn:serviceTask>/)?.[0];
+    if (!agentTask) {
+        throw new Error('The BPMN fixture has no AI_Agent service task');
+    }
+    return agentTask;
+}
+function replaceAgentTask(bpmn, agentTask, updatedTask) {
+    return bpmn.replace(agentTask, updatedTask);
+}
+function replaceInputSource(bpmn, target, source) {
+    const agentTask = getAgentTask(bpmn);
+    const input = (agentTask.match(/<zeebe:input\b[\s\S]*?\/>/g) ?? []).find((entry) => entry.includes(`target="${target}"`));
+    if (!input) {
+        throw new Error(`The BPMN fixture has no input mapping for ${target}`);
+    }
+    const updatedInput = input.replace(/\bsource="[^"]*"/, `source="${escapeXml(source)}"`);
+    return replaceAgentTask(bpmn, agentTask, agentTask.replace(input, updatedInput));
+}
+function appendInputMappings(bpmn, mappings) {
+    const closingTag = '</zeebe:ioMapping>';
+    const agentTask = getAgentTask(bpmn);
+    const index = agentTask.indexOf(closingTag);
+    if (index < 0) {
+        throw new Error('The AI_Agent task has no zeebe:ioMapping element');
+    }
+    const newMappings = mappings
+        .map(({ source, target }) => `          <zeebe:input source="${escapeXml(source)}" target="${escapeXml(target)}" />`)
+        .join('\n');
+    const updatedTask = `${agentTask.slice(0, index)}${newMappings}\n${agentTask.slice(index)}`;
+    return replaceAgentTask(bpmn, agentTask, updatedTask);
+}
+function markAgentTask(bpmn) {
+    const agentTask = getAgentTask(bpmn);
+    if (!agentTask.includes('</bpmn:extensionElements>')) {
+        throw new Error('The BPMN fixture has no AI_Agent task extensions');
+    }
+    if (/<zeebe:agentDefinition\b/.test(agentTask)) {
+        throw new Error('The BPMN fixture already has an AI_Agent definition');
+    }
+    return replaceAgentTask(bpmn, agentTask, agentTask.replace('</bpmn:extensionElements>', '  <zeebe:agentDefinition agentType="aiAgentTask" />\n' +
+        '      </bpmn:extensionElements>'));
+}
+function buildAgentReasoningBpmn(bpmnPath, processId, processName, provider) {
+    let bpmn = replaceProcessIdentity(fs_1.default.readFileSync(bpmnPath, 'utf8'), processId, processName);
+    bpmn = markAgentTask(bpmn);
+    bpmn = replaceInputSource(bpmn, 'data.systemPrompt.prompt', REASONING_SYSTEM_PROMPT);
+    bpmn = replaceInputSource(bpmn, 'data.userPrompt.prompt', REASONING_USER_PROMPT);
+    if (provider === 'anthropic-adaptive') {
+        bpmn = replaceInputSource(bpmn, 'data.limits.maxModelCalls', '=3');
+        bpmn = appendInputMappings(bpmn, [
+            {
+                source: '=8192',
+                target: 'provider.anthropic.model.parameters.maxTokens',
+            },
+            {
+                source: 'adaptive',
+                target: 'provider.anthropic.model.parameters.thinking.mode',
+            },
+            {
+                source: 'summarized',
+                target: 'provider.anthropic.model.parameters.thinking.display',
+            },
+            {
+                source: 'high',
+                target: 'provider.anthropic.model.parameters.effort',
+            },
+        ]);
+    }
+    else {
+        bpmn = replaceInputSource(bpmn, 'provider.openai.model.model', 'gpt-5-mini-2025-08-07');
+        bpmn = replaceInputSource(bpmn, 'data.limits.maxModelCalls', '=3');
+        bpmn = appendInputMappings(bpmn, [
+            {
+                source: 'medium',
+                target: 'provider.openai.api.responses.effort',
+            },
+            {
+                source: '=4096',
+                target: 'provider.openai.api.responses.maxOutputTokens',
+            },
+        ]);
+    }
+    return bpmn;
+}
+exports.buildAgentReasoningBpmn = buildAgentReasoningBpmn;

package/package.json

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