@aifabrix/builder 2.53.1 → 2.55.0

package/lib/role-assistant/test-runner-start-payload.js

@@ -37,6 +37,16 @@ function resolveInputMessage(testCase) {
   return '';
 }
 
+function applyObjectiveField(payload, message) {
+  if (message) {
+    payload.objective = message;
+    return;
+  }
+  if (typeof payload.content === 'string' && payload.content.trim()) {
+    payload.objective = payload.content.trim();
+  }
+}
+
 function applyStartPayloadOptionalFields(payload, input) {
   const mappedFields = [
     ['activationId', 'activationId'],
@@ -58,34 +68,77 @@ function buildStartPayloadSourceMetadata(roleKey, testCase, input) {
   };
 }
 
-function buildStartIntentPayload(roleKey, testCase) {
-  const input = resolveInputObject(testCase);
-  const message = resolveInputMessage(testCase);
-  const hasContent = typeof input.content !== 'undefined';
+function resolveCaseMetadata(testCase) {
+  if (testCase && typeof testCase.metadata === 'object' && testCase.metadata) {
+    return testCase.metadata;
+  }
+  return {};
+}
+
+function resolveLearningLevel(metadata) {
+  if (typeof metadata.learningLevel === 'string' && metadata.learningLevel.trim()) {
+    return metadata.learningLevel.trim();
+  }
+  return null;
+}
+
+function assertHasStartContent(testCase, hasContent, message) {
   if (!hasContent && !message) {
     throw new Error(
       `Role assistant test case "${testCase.caseId}" is missing input.message or input.content for runtime execution.`
     );
   }
-  const payload = {
+}
+
+function resolveComVocabulary(input) {
+  if (Array.isArray(input.comVocabulary) && input.comVocabulary.length > 0) {
+    return input.comVocabulary.map((row) => String(row));
+  }
+  return ['objective', 'entity', 'action'];
+}
+
+function buildStartIntentBasePayload(roleKey, testCase, input, message, hasContent) {
+  return {
     submissionId: String(input.submissionId || buildRuntimeId(`ra-${roleKey}`)),
     content: hasContent ? input.content : message,
     comModelRef: String(input.comModelRef || 'aifabrix.com/intent/default'),
     comModelVersion: String(input.comModelVersion || '1.0'),
-    comVocabulary:
-      Array.isArray(input.comVocabulary) && input.comVocabulary.length > 0
-        ? input.comVocabulary.map((row) => String(row))
-        : ['objective', 'entity', 'action'],
+    comVocabulary: resolveComVocabulary(input),
     sourceType: String(input.sourceType || 'api'),
     sourceLanguage: String(input.sourceLanguage || 'en'),
     responseLanguage: String(input.responseLanguage || input.sourceLanguage || 'en'),
     sourceMetadata: buildStartPayloadSourceMetadata(roleKey, testCase, input)
   };
-  applyStartPayloadOptionalFields(payload, input);
+}
+
+function applyLearningLevel(payload, learningLevel) {
+  if (learningLevel === null) {
+    return;
+  }
+  payload.learningLevel = learningLevel;
+  payload.sourceMetadata = {
+    ...(payload.sourceMetadata || {}),
+    learningLevel
+  };
+}
+
+function applyStartAttachments(payload, testCase) {
   const attachments = buildStartAttachments(testCase);
   if (attachments && attachments.length > 0) {
     payload.attachments = attachments;
   }
+}
+
+function buildStartIntentPayload(roleKey, testCase) {
+  const input = resolveInputObject(testCase);
+  const message = resolveInputMessage(testCase);
+  const hasContent = typeof input.content !== 'undefined';
+  assertHasStartContent(testCase, hasContent, message);
+  const payload = buildStartIntentBasePayload(roleKey, testCase, input, message, hasContent);
+  applyObjectiveField(payload, message);
+  applyStartPayloadOptionalFields(payload, input);
+  applyLearningLevel(payload, resolveLearningLevel(resolveCaseMetadata(testCase)));
+  applyStartAttachments(payload, testCase);
   return payload;
 }
 

package/lib/role-assistant/test-runner-workhub-answers.js

@@ -11,6 +11,7 @@ const {
   resolveSuiteRunId,
   loadCaseBidDocument
 } = require('./test-runner-bid-document');
+const { pickHumanRespondBody } = require('./test-runner-respond-body');
 
 function resolveWorkHubAnswerValue(answer) {
   if (answer === null || answer === undefined) {
@@ -31,24 +32,41 @@ function resolveWorkHubAnswerValue(answer) {
   return undefined;
 }
 
+function asPlainObject(value) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    return {};
+  }
+  return value;
+}
+
+function firstNormalizedKey(candidates) {
+  for (const part of candidates) {
+    const text = String(part || '').trim().toLowerCase();
+    if (text) {
+      return text;
+    }
+  }
+  return '';
+}
+
+function waitQuestionKey(wait) {
+  const row = asPlainObject(wait);
+  const objectRef = asPlainObject(row.objectRef);
+  return firstNormalizedKey([row.questionKey, row.requestKey, objectRef.capabilityKey]);
+}
+
+function answerWhenKey(entry) {
+  const when = asPlainObject(asPlainObject(entry).when);
+  return firstNormalizedKey([when.questionKey, when.requestKey, when.key]);
+}
+
 function pickAnswerForWait(answers, wait) {
-  const questionKey = String(wait.questionKey || wait.requestKey || '').trim().toLowerCase();
+  const questionKey = waitQuestionKey(wait);
   if (!questionKey) {
     return null;
   }
-  for (const entry of answers) {
-    if (!entry || typeof entry !== 'object') {
-      continue;
-    }
-    const when = entry.when && typeof entry.when === 'object' ? entry.when : {};
-    const matchKey = String(when.questionKey || when.requestKey || when.key || '')
-      .trim()
-      .toLowerCase();
-    if (matchKey && matchKey === questionKey) {
-      return entry;
-    }
-  }
-  return null;
+  const list = Array.isArray(answers) ? answers : [];
+  return list.find((entry) => answerWhenKey(entry) === questionKey) || null;
 }
 
 function parseFieldsFromPrompt(prompt) {
@@ -423,14 +441,25 @@ function buildRespondPayload(peId, wait, testCase, statusRow, interactions, obje
   };
   if (answerType === 'approval') {
     payload.approvalDecision = 'approved';
-    return payload;
+    return pickHumanRespondBody(payload);
   }
   const value = resolveRespondValue(testCase, wait, statusRow, objective);
   if (value === undefined) {
     return null;
   }
+  const choiceIds = Array.isArray(wait.allowedChoiceIds) ? wait.allowedChoiceIds : [];
+  const isChoice =
+    String(wait.interactionKind || '').toLowerCase() === 'choice' || choiceIds.length > 0;
+  if (isChoice) {
+    const selected = typeof value === 'string' ? value.trim() : '';
+    if (!selected) {
+      return null;
+    }
+    payload.selectedOptionId = selected;
+    return pickHumanRespondBody(payload);
+  }
   payload.value = value;
-  return payload;
+  return pickHumanRespondBody(payload);
 }
 
 module.exports = {

package/lib/role-assistant/test-runner-workhub-helpers.js

@@ -34,9 +34,45 @@ function resolveObjective(testCase) {
   return '';
 }
 
-function wantsWorkHubPath(testCase) {
+function firstNonEmptyString(values) {
+  for (const value of values) {
+    if (typeof value === 'string' && value.trim()) {
+      return value.trim();
+    }
+  }
+  return '';
+}
+
+function searchPathToken(testCase) {
   const input = resolveInput(testCase);
-  const pathToken = String(input.executionPath || input.mode || '').trim().toLowerCase();
+  return firstNonEmptyString([
+    input.executionPath,
+    input.execution_path,
+    testCase && testCase.executionPath,
+    input.mode
+  ]).toLowerCase();
+}
+
+function wantsSearchPath(testCase) {
+  const pathToken = searchPathToken(testCase);
+  return (
+    pathToken === 'search' ||
+    pathToken === 'work.search' ||
+    pathToken === 'skills' ||
+    pathToken === 'work.skills'
+  );
+}
+
+function wantsSkillsOnlyPath(testCase) {
+  const pathToken = searchPathToken(testCase);
+  return pathToken === 'skills' || pathToken === 'work.skills';
+}
+
+function wantsWorkHubPath(testCase) {
+  if (wantsSearchPath(testCase)) {
+    return false;
+  }
+  const pathToken = searchPathToken(testCase);
   if (pathToken === 'workhub' || pathToken === 'work-hub' || pathToken === 'plan') {
     return true;
   }
@@ -91,6 +127,8 @@ module.exports = {
   delayMs,
   resolveInput,
   resolveObjective,
+  wantsSearchPath,
+  wantsSkillsOnlyPath,
   wantsWorkHubPath,
   unwrapId,
   extractPeFromTask,

package/lib/role-assistant/test-runner-workhub-soft.js

@@ -1,14 +1,20 @@
 /**
  * Soft Work Hub outcomes for insufficient-info / clarify-first Intent.
- * Soft cases may stop before accept when Intent is not Act-ready — that is a
- * governed fail-closed outcome, not a harness failure.
+ * Soft cases may stop before accept when Intent is not Act-ready or cannot be
+ * classified (unavailable without a next question) — that is a governed
+ * fail-closed outcome, not a harness failure.
  */
 
 'use strict';
 
 function isIntentNotActReadyError(error) {
   const msg = String((error && error.message) || error || '');
-  return /not Act-ready|intentNotActReady/i.test(msg);
+  const type = String((error && (error.errorType || error.type)) || '');
+  return (
+    /not Act-ready|intentNotActReady/i.test(msg) ||
+    /Intent is not available|runtimeIntentUnavailable/i.test(msg) ||
+    /runtimeIntentUnavailable/i.test(type)
+  );
 }
 
 function attachPlanIdToError(error, planId) {

package/lib/role-assistant/test-runner-workhub.js

@@ -14,8 +14,7 @@ const {
   approveWorkTask,
   getWorkExecutionStatus,
   respondWorkExecution,
-  continueWorkExecution,
-  getWorkExecutionResult
+  continueWorkExecution
 } = require('../api/work.api');
 const {
   synthesizeWaitAnswer,
@@ -302,21 +301,36 @@ function assertTerminalWorkHubTask(last, taskId, timeoutMs, options = {}) {
     throw new Error(`Work Hub task ${taskId} produced no status rows.`);
   }
   const finalStatusToken = String(last?.status || last?.taskStatus || '').trim().toLowerCase();
-  if (!TERMINAL_TASK.has(finalStatusToken)) {
-    if (options.soft === true) {
-      return last;
-    }
-    throw new Error(
-      `Work Hub task ${taskId} did not reach a terminal status within ${timeoutMs}ms (last=${finalStatusToken || 'unknown'}).`
-    );
+  if (!TERMINAL_TASK.has(finalStatusToken) && options.recordTimeout === true) {
+    last = {
+      ...last,
+      pollTimedOut: true,
+      lastStatus: finalStatusToken || 'unknown',
+      pollTimeoutMs: timeoutMs
+    };
   }
   return last;
 }
 
+function shouldStopPendingApprovalPoll(status, ctx) {
+  if (status !== 'pendingapproval' && status !== 'pending_approval') {
+    return false;
+  }
+  return ctx.approveStopped === true && (Number(ctx.pendingApprovalStreak) || 0) >= 3;
+}
+
+function applyWorkHubPollStatus(ctx, last, status) {
+  ctx.status = status;
+  ctx.taskRow = last;
+  ctx.pendingApprovalStreak =
+    status === 'pendingapproval' || status === 'pending_approval'
+      ? (Number(ctx.pendingApprovalStreak) || 0) + 1
+      : 0;
+}
+
 async function pollWorkHubTask(dataplaneUrl, authConfig, taskId, testCase, options) {
   const timeoutMs = Number(options.pollTimeoutMs) || 180000;
   const intervalMs = Number(options.pollIntervalMs) || 3000;
-  const soft = testCase?.expected?.soft === true;
   const started = Date.now();
   let last = null;
   const timeline = [];
@@ -324,6 +338,7 @@ async function pollWorkHubTask(dataplaneUrl, authConfig, taskId, testCase, optio
     status: '',
     approveAttempts: 0,
     approveStopped: false,
+    pendingApprovalStreak: 0,
     interactions: [],
     taskRow: null
   };
@@ -335,30 +350,25 @@ async function pollWorkHubTask(dataplaneUrl, authConfig, taskId, testCase, optio
     if (TERMINAL_TASK.has(status)) {
       break;
     }
-    ctx.status = status;
-    ctx.taskRow = last;
+    applyWorkHubPollStatus(ctx, last, status);
     await maybeApproveTask(dataplaneUrl, authConfig, taskId, ctx);
     await maybeRespondWaiting(dataplaneUrl, authConfig, last, testCase, ctx.interactions);
+    if (shouldStopPendingApprovalPoll(status, ctx)) {
+      break;
+    }
     await delayMs(intervalMs);
   }
 
   return {
-    finalTask: assertTerminalWorkHubTask(last, taskId, timeoutMs, { soft }),
+    finalTask: assertTerminalWorkHubTask(last, taskId, timeoutMs, { recordTimeout: true }),
     timeline,
     interactions: ctx.interactions
   };
 }
 
-async function fetchBusinessResult(dataplaneUrl, authConfig, processExecutionId) {
-  try {
-    const workResult = await getWorkExecutionResult(dataplaneUrl, authConfig, processExecutionId, {
-      requestedDepth: 'business',
-      format: 'json'
-    });
-    return { workResult, workResultError: null };
-  } catch (error) {
-    return { workResult: null, workResultError: error.message || String(error) };
-  }
+async function fetchBusinessResult(dataplaneUrl, authConfig, processExecutionId, options = {}) {
+  const { fetchWorkHubResult } = require('./test-runner-debug');
+  return fetchWorkHubResult(dataplaneUrl, authConfig, processExecutionId, options);
 }
 
 function buildWorkHubLifecycleResult(roleKey, testCase, started, pollState, peBundle) {
@@ -388,6 +398,38 @@ function buildWorkHubLifecycleResult(roleKey, testCase, started, pollState, peBu
   };
 }
 
+async function finishWorkHubAfterPoll(args) {
+  const {
+    roleKey,
+    testCase,
+    started,
+    pollState,
+    dataplaneUrl,
+    authConfig,
+    options
+  } = args;
+  const processExecutionId = extractPeFromTask(pollState.finalTask);
+  if (!processExecutionId) {
+    throw new Error(`Work Hub task ${started.taskId} finished without processExecutionId.`);
+  }
+  const { persistRoleAssistantDebugLog } = require('./test-runner-debug');
+  const peBundle = {
+    processExecutionId,
+    ...(await fetchBusinessResult(dataplaneUrl, authConfig, processExecutionId, options))
+  };
+  await persistRoleAssistantDebugLog(
+    roleKey,
+    {
+      processExecutionId,
+      requestedDepth: options && options.debug === true ? 'technical' : 'business',
+      workResult: peBundle.workResult,
+      workResultError: peBundle.workResultError
+    },
+    options
+  );
+  return buildWorkHubLifecycleResult(roleKey, testCase, started, pollState, peBundle);
+}
+
 async function runWorkHubCaseLifecycle(roleKey, testCase, runtimeContext, options = {}) {
   const { startWorkHubOrSoftClarify } = require('./test-runner-workhub-soft');
   const dataplaneUrl = runtimeContext?.dataplaneUrl;
@@ -422,15 +464,15 @@ async function runWorkHubCaseLifecycle(roleKey, testCase, runtimeContext, option
     testCase,
     options
   );
-  const processExecutionId = extractPeFromTask(pollState.finalTask);
-  if (!processExecutionId) {
-    throw new Error(`Work Hub task ${started.taskId} finished without processExecutionId.`);
-  }
-  const peBundle = {
-    processExecutionId,
-    ...(await fetchBusinessResult(dataplaneUrl, authConfig, processExecutionId))
-  };
-  return buildWorkHubLifecycleResult(roleKey, testCase, started, pollState, peBundle);
+  return finishWorkHubAfterPoll({
+    roleKey,
+    testCase,
+    started,
+    pollState,
+    dataplaneUrl,
+    authConfig,
+    options
+  });
 }
 
 module.exports = {

package/lib/role-assistant/test-runner.js

@@ -18,11 +18,13 @@ const {
   getWorkExecutionResult
 } = require('../api/work.api');
 const { wantsWorkHubPath, runWorkHubCaseLifecycle } = require('./test-runner-workhub');
+const { wantsSearchPath, runSearchCaseLifecycle } = require('./test-runner-search');
 const {
   buildStartIntentPayload,
   resolveInputObject,
   resolveInputMessage
 } = require('./test-runner-start-payload');
+const { pickHumanRespondBody } = require('./test-runner-respond-body');
 const TERMINAL_STATUSES = new Set(['completed', 'stopped']);
 const WAITING_STATUS = 'waiting';
 
@@ -58,6 +60,9 @@ function applyOptionalStringField(payload, value, key) {
 }
 
 function isExecutableRoleAssistantCase(testCase) {
+  if (wantsSearchPath(testCase)) {
+    return true;
+  }
   const input = resolveInputObject(testCase);
   if (typeof input.content !== 'undefined') {
     return true;
@@ -70,6 +75,7 @@ function isExecutableRoleAssistantCase(testCase) {
 
 function extractProcessExecutionId(startResponse) {
   const candidates = [
+    startResponse?.work?.processExecutionId,
     startResponse?.intent?.processExecutionId,
     startResponse?.processExecutionId,
     startResponse?.status?.processExecutionId
@@ -107,6 +113,8 @@ function collectWaitMatchTokens(wait) {
     add(wait.objectRef.name);
     add(wait.objectRef.type);
     add(wait.objectRef.id);
+    add(wait.objectRef.capabilityKey);
+    add(wait.objectRef.resourceType);
   }
   if (wait.safeProjection && typeof wait.safeProjection === 'object') {
     add(wait.safeProjection.capabilityKey);
@@ -193,22 +201,40 @@ function applyWaitVersioningFields(payload, wait) {
   applyOptionalStringField(payload, wait.requestFingerprint, 'requestFingerprint');
 }
 
+function waitIsChoice(wait) {
+  const ids = wait && Array.isArray(wait.allowedChoiceIds) ? wait.allowedChoiceIds : [];
+  return String((wait && wait.interactionKind) || '').toLowerCase() === 'choice' || ids.length > 0;
+}
+
+function choiceIdFromAnswer(answerEntry, respond) {
+  if (typeof respond.selectedOptionId === 'string' && respond.selectedOptionId.trim()) {
+    return respond.selectedOptionId.trim();
+  }
+  if (typeof answerEntry?.value === 'string' && answerEntry.value.trim()) {
+    return answerEntry.value.trim();
+  }
+  return '';
+}
+
 function buildAskRespondPayload(answerEntry, wait) {
   const respond = answerEntry && typeof answerEntry.respond === 'object' && answerEntry.respond
     ? answerEntry.respond
     : {};
   const payload = {
     respondIdempotencyKey: buildRuntimeId('ra-answer'),
-    answerType: 'ask',
-    value: resolveAskRespondValue(respond)
+    answerType: 'ask'
   };
-  applyOptionalStringField(payload, respond.selectedOptionId, 'selectedOptionId');
-  applyOptionalStringField(payload, respond.evidenceRef, 'evidenceRef');
+  if (waitIsChoice(wait)) {
+    applyOptionalStringField(payload, choiceIdFromAnswer(answerEntry, respond), 'selectedOptionId');
+  } else {
+    payload.value = resolveAskRespondValue(Object.keys(respond).length ? respond : answerEntry);
+    applyOptionalStringField(payload, respond.evidenceRef, 'evidenceRef');
+  }
   if (respond.declined === true) {
     payload.declined = true;
   }
   applyWaitVersioningFields(payload, wait);
-  return payload;
+  return pickHumanRespondBody(payload);
 }
 
 function buildApprovalRespondPayload(approvalEntry, wait) {
@@ -224,7 +250,7 @@ function buildApprovalRespondPayload(approvalEntry, wait) {
     approvalDecision: decision
   };
   applyWaitVersioningFields(payload, wait);
-  return payload;
+  return pickHumanRespondBody(payload);
 }
 
 function buildStatusSnapshot(statusRow) {
@@ -243,7 +269,8 @@ function buildRunnerOptions(options = {}) {
   return {
     maxStatusPolls: Number.isFinite(maxStatusPolls) && maxStatusPolls > 0 ? maxStatusPolls : 20,
     statusPollIntervalMs:
-      Number.isFinite(statusPollIntervalMs) && statusPollIntervalMs >= 0 ? statusPollIntervalMs : 750
+      Number.isFinite(statusPollIntervalMs) && statusPollIntervalMs >= 0 ? statusPollIntervalMs : 750,
+    debug: options.debug === true
   };
 }
 
@@ -266,6 +293,18 @@ function finalizeWaitingAdvanceStatus(respondResult, continueResult) {
     : afterRespondStatus;
 }
 
+async function continueAfterRespond(dataplaneUrl, authConfig, processExecutionId) {
+  try {
+    return await continueWorkExecution(dataplaneUrl, authConfig, processExecutionId, {});
+  } catch (error) {
+    const text = String(error && error.message ? error.message : error);
+    if (/already terminal/i.test(text)) {
+      return getWorkExecutionStatus(dataplaneUrl, authConfig, processExecutionId);
+    }
+    throw error;
+  }
+}
+
 async function advanceApprovalWaitingExecution(context, approvals, wait) {
   const { dataplaneUrl, authConfig, processExecutionId, usedApprovalIndexes } = context;
   const match = findMatchingEntry(approvals, usedApprovalIndexes, wait);
@@ -275,7 +314,7 @@ async function advanceApprovalWaitingExecution(context, approvals, wait) {
   usedApprovalIndexes.add(match.index);
   const payload = buildApprovalRespondPayload(match.entry, wait);
   const respondResult = await respondWorkExecution(dataplaneUrl, authConfig, processExecutionId, payload);
-  const continueResult = await continueWorkExecution(dataplaneUrl, authConfig, processExecutionId, {});
+  const continueResult = await continueAfterRespond(dataplaneUrl, authConfig, processExecutionId);
   return {
     status: finalizeWaitingAdvanceStatus(respondResult, continueResult),
     matched: true,
@@ -293,7 +332,7 @@ async function advanceAskWaitingExecution(context, answers, wait) {
   usedAnswerIndexes.add(match.index);
   const payload = buildAskRespondPayload(match.entry, wait);
   const respondResult = await respondWorkExecution(dataplaneUrl, authConfig, processExecutionId, payload);
-  const continueResult = await continueWorkExecution(dataplaneUrl, authConfig, processExecutionId, {});
+  const continueResult = await continueAfterRespond(dataplaneUrl, authConfig, processExecutionId);
   return {
     status: finalizeWaitingAdvanceStatus(respondResult, continueResult),
     matched: true,
@@ -340,7 +379,11 @@ async function pollCaseExecutionStatus(dataplaneUrl, authConfig, processExecutio
         type: advanced.interactionType,
         waitReason: wait.waitReason || wait.answerType || wait.interactionKind || null,
         matched: advanced.matched === true,
-        questionKey: wait.questionKey || wait.requestKey || null
+        questionKey:
+          wait.questionKey ||
+          wait.requestKey ||
+          (wait.objectRef && wait.objectRef.capabilityKey) ||
+          null
       });
       if (!advanced.matched || !advanced.status) {
         break;
@@ -370,6 +413,9 @@ async function runRoleAssistantCaseLifecycle(roleKey, testCase, runtimeContext,
     throw new Error('Role assistant case runtime requires dataplane auth context.');
   }
   const runnerOptions = buildRunnerOptions(options);
+  if (wantsSearchPath(testCase)) {
+    return runSearchCaseLifecycle(roleKey, testCase, runtimeContext, runnerOptions);
+  }
   if (wantsWorkHubPath(testCase)) {
     return runWorkHubCaseLifecycle(roleKey, testCase, runtimeContext, runnerOptions);
   }
@@ -418,11 +464,19 @@ function mergeCaseExecutionIntoLifecycleResult(lifecycleResult, executionResult)
     task: executionResult?.workResult?.task || null,
     steps: Array.isArray(executionResult?.workResult?.steps) ? executionResult.workResult.steps : [],
     workTimeline: executionResult?.timeline || [],
-    workInteractions: executionResult?.interactions || []
+    workInteractions: executionResult?.interactions || [],
+    search: executionResult?.search || null,
+    skills: executionResult?.skills || null,
+    roleRef: executionResult?.roleRef || null
   };
 }
 
 function lifecycleVerdictFromCaseExecution(executionResult, fallbackVerdict) {
+  if (executionResult?.kind === 'search' || executionResult?.kind === 'skills') {
+    return Number.isFinite(Number(executionResult.search?.status || executionResult.skills?.status))
+      ? VERDICT.VERIFIED
+      : VERDICT.FAILED;
+  }
   const statusToken = normalizeToken(executionResult?.finalStatus?.status);
   if (statusToken === 'completed') {
     return VERDICT.VERIFIED;
@@ -436,6 +490,7 @@ function lifecycleVerdictFromCaseExecution(executionResult, fallbackVerdict) {
 module.exports = {
   isExecutableRoleAssistantCase,
   buildStartIntentPayload,
+  buildRunnerOptions,
   runRoleAssistantCaseLifecycle,
   mergeCaseExecutionIntoLifecycleResult,
   lifecycleVerdictFromCaseExecution