@aifabrix/builder 2.51.0 → 2.51.1

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

@@ -0,0 +1,385 @@
+/**
+ * Work Hub plan → activate → accept path for role-assistant test cases.
+ * Retries create→accept when Docker reload wipes in-process plans.
+ * @fileoverview Work Hub execution for RA cases
+ */
+
+'use strict';
+
+const {
+  createWorkTaskPlan,
+  activateWorkPlanAssistant,
+  acceptWorkTaskPlan,
+  getWorkTask,
+  approveWorkTask,
+  getWorkExecutionStatus,
+  respondWorkExecution,
+  continueWorkExecution,
+  getWorkExecutionResult
+} = require('../api/work.api');
+const {
+  synthesizeWaitAnswer,
+  waitRespondFingerprint,
+  alreadyResponded,
+  buildRespondPayload
+} = require('./test-runner-workhub-answers');
+
+const TERMINAL_TASK = new Set(['completed', 'failed', 'cancelled', 'canceled']);
+const PLAN_LOST_RE =
+  /work plan not found|plan not found|404|ephemeral|reload|timed out|timeout|network error|econnreset|socket|fetch failed/i;
+const APPROVAL_NOT_PENDING_RE = /approval state is not pending|not pending/i;
+
+function delayMs(ms) {
+  const wait = Number(ms);
+  if (!Number.isFinite(wait) || wait <= 0) {
+    return Promise.resolve();
+  }
+  return new Promise((resolve) => setTimeout(resolve, wait));
+}
+
+function resolveInput(testCase) {
+  const input = testCase && typeof testCase.input === 'object' && testCase.input ? testCase.input : {};
+  return Array.isArray(input) ? {} : input;
+}
+
+function resolveObjective(testCase) {
+  const input = resolveInput(testCase);
+  const candidates = [input.message, input.text, input.prompt, input.objective];
+  for (const row of candidates) {
+    if (typeof row === 'string' && row.trim()) {
+      return row.trim();
+    }
+  }
+  return '';
+}
+
+function wantsWorkHubPath(testCase) {
+  const input = resolveInput(testCase);
+  const pathToken = String(input.executionPath || input.mode || '').trim().toLowerCase();
+  if (pathToken === 'workhub' || pathToken === 'work-hub' || pathToken === 'plan') {
+    return true;
+  }
+  if (pathToken === 'work.start' || pathToken === 'start' || pathToken === 'intent') {
+    return false;
+  }
+  return Boolean(resolveObjective(testCase));
+}
+
+function unwrapId(value) {
+  if (typeof value === 'string' && value.trim()) {
+    return value.trim();
+  }
+  if (value && typeof value === 'object') {
+    const nested = value.id || value.value || value.ref;
+    if (typeof nested === 'string' && nested.trim()) {
+      return nested.trim();
+    }
+  }
+  return '';
+}
+
+function extractPeFromTask(task) {
+  const candidates = [task?.processExecutionId, task?.processExecutionRef];
+  for (const row of candidates) {
+    const id = unwrapId(row);
+    if (id) {
+      return id;
+    }
+  }
+  return '';
+}
+
+function planAlreadyActivated(plan) {
+  const assistant = plan?.recommendedAssistant;
+  if (!assistant || typeof assistant !== 'object' || assistant.isActivated !== true) {
+    return false;
+  }
+  return Boolean(unwrapId(assistant.activationId));
+}
+
+function isPlanLostError(error) {
+  return PLAN_LOST_RE.test(String((error && error.message) || error || ''));
+}
+
+function isApprovalNotPendingError(error) {
+  return APPROVAL_NOT_PENDING_RE.test(String((error && error.message) || error || ''));
+}
+
+async function waitDataplaneHealthy(dataplaneUrl, attempts = 12) {
+  const base = String(dataplaneUrl || '')
+    .replace(/\/+$/, '')
+    .replace(/\/api\/v1$/, '');
+  if (!base) {
+    return;
+  }
+  for (let i = 0; i < attempts; i += 1) {
+    try {
+      const res = await fetch(`${base}/health`);
+      if (res.ok) {
+        return;
+      }
+    } catch (_err) {
+      // Reload in progress.
+    }
+    await delayMs(500 + i * 250);
+  }
+}
+
+async function activateIfNeeded(dataplaneUrl, authConfig, plan, assistantName) {
+  const planId = String(plan.planId || '').trim();
+  if (!planId) {
+    throw new Error('work.tasks.plan did not return planId.');
+  }
+  if (!planAlreadyActivated(plan)) {
+    await activateWorkPlanAssistant(dataplaneUrl, authConfig, planId, {
+      planId,
+      assistantName
+    });
+  }
+  return planId;
+}
+
+async function acceptPlanForTask(dataplaneUrl, authConfig, planId) {
+  const accepted = await acceptWorkTaskPlan(dataplaneUrl, authConfig, planId, { planId });
+  const taskId = String(accepted.taskId || unwrapId(accepted.id) || '').trim();
+  if (!taskId) {
+    throw new Error('work.tasks.plan.accept did not return taskId.');
+  }
+  return taskId;
+}
+
+async function createActivateAcceptOnce(dataplaneUrl, authConfig, planBody, assistantName) {
+  await waitDataplaneHealthy(dataplaneUrl);
+  const plan = await createWorkTaskPlan(dataplaneUrl, authConfig, planBody);
+  const planId = await activateIfNeeded(dataplaneUrl, authConfig, plan, assistantName);
+  const taskId = await acceptPlanForTask(dataplaneUrl, authConfig, planId);
+  return { planId, taskId };
+}
+
+async function createActivateAcceptPlan(dataplaneUrl, authConfig, planBody, assistantName, options) {
+  const maxAttempts = Number(options.planRetryAttempts) || 5;
+  let lastError = null;
+  for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+    try {
+      const started = await createActivateAcceptOnce(
+        dataplaneUrl,
+        authConfig,
+        planBody,
+        assistantName
+      );
+      return { ...started, attempt };
+    } catch (error) {
+      lastError = error;
+      if (!isPlanLostError(error) || attempt >= maxAttempts) {
+        throw error;
+      }
+      await waitDataplaneHealthy(dataplaneUrl);
+      await delayMs(400 * attempt);
+    }
+  }
+  throw lastError || new Error('Work Hub plan create/activate/accept failed.');
+}
+
+async function maybeApproveTask(dataplaneUrl, authConfig, taskId, ctx) {
+  if (ctx.approveStopped) {
+    return;
+  }
+  const status = String(ctx.status || '').trim().toLowerCase();
+  if (status !== 'pendingapproval' && status !== 'pending_approval') {
+    return;
+  }
+  const approvalState = String(ctx.taskRow?.approvalState || '').trim().toLowerCase();
+  if (approvalState && approvalState !== 'pending') {
+    ctx.approveStopped = true;
+    return;
+  }
+  if ((Number(ctx.approveAttempts) || 0) >= 8) {
+    ctx.approveStopped = true;
+    return;
+  }
+  try {
+    await approveWorkTask(dataplaneUrl, authConfig, taskId, {});
+    ctx.interactions.push({ type: 'approve', taskId, attempt: ctx.approveAttempts });
+    ctx.approveAttempts += 1;
+  } catch (err) {
+    if (isApprovalNotPendingError(err)) {
+      ctx.approveStopped = true;
+      ctx.interactions.push({ type: 'approveStopped', reason: 'notPending', taskId });
+      return;
+    }
+    ctx.approveAttempts += 1;
+  }
+}
+
+async function maybeRespondWaiting(dataplaneUrl, authConfig, taskRow, testCase, interactions) {
+  const peId = extractPeFromTask(taskRow);
+  if (!peId) {
+    return;
+  }
+  try {
+    const statusRow = await getWorkExecutionStatus(dataplaneUrl, authConfig, peId);
+    if (String(statusRow?.status || '').toLowerCase() !== 'waiting') {
+      return;
+    }
+    const wait = statusRow.wait && typeof statusRow.wait === 'object' ? statusRow.wait : {};
+    const fingerprint = waitRespondFingerprint(wait);
+    if (alreadyResponded(interactions, fingerprint)) {
+      return;
+    }
+    const payload = buildRespondPayload(
+      peId,
+      wait,
+      testCase,
+      statusRow,
+      interactions,
+      resolveObjective(testCase)
+    );
+    if (!payload) {
+      return;
+    }
+    await respondWorkExecution(dataplaneUrl, authConfig, peId, payload);
+    await continueWorkExecution(dataplaneUrl, authConfig, peId, {});
+    interactions.push({ type: 'respond', processExecutionId: peId, fingerprint });
+  } catch (_err) {
+    // Soft: continue polling task.
+  }
+}
+
+function assertTerminalWorkHubTask(last, taskId, timeoutMs) {
+  if (!last) {
+    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)) {
+    throw new Error(
+      `Work Hub task ${taskId} did not reach a terminal status within ${timeoutMs}ms (last=${finalStatusToken || 'unknown'}).`
+    );
+  }
+  return last;
+}
+
+async function pollWorkHubTask(dataplaneUrl, authConfig, taskId, testCase, options) {
+  const timeoutMs = Number(options.pollTimeoutMs) || 180000;
+  const intervalMs = Number(options.pollIntervalMs) || 3000;
+  const started = Date.now();
+  let last = null;
+  const timeline = [];
+  const ctx = {
+    status: '',
+    approveAttempts: 0,
+    approveStopped: false,
+    interactions: [],
+    taskRow: null
+  };
+
+  while (Date.now() - started < timeoutMs) {
+    last = await getWorkTask(dataplaneUrl, authConfig, taskId);
+    const status = String(last?.status || last?.taskStatus || '').trim().toLowerCase();
+    timeline.push({ at: new Date().toISOString(), status, taskId });
+    if (TERMINAL_TASK.has(status)) {
+      break;
+    }
+    ctx.status = status;
+    ctx.taskRow = last;
+    await maybeApproveTask(dataplaneUrl, authConfig, taskId, ctx);
+    await maybeRespondWaiting(dataplaneUrl, authConfig, last, testCase, ctx.interactions);
+    await delayMs(intervalMs);
+  }
+
+  return {
+    finalTask: assertTerminalWorkHubTask(last, taskId, timeoutMs),
+    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) };
+  }
+}
+
+function buildWorkHubLifecycleResult(roleKey, testCase, started, pollState, peBundle) {
+  const taskStatus = String(
+    pollState.finalTask?.status || pollState.finalTask?.taskStatus || ''
+  )
+    .trim()
+    .toLowerCase();
+  return {
+    roleKey,
+    caseId: testCase.caseId,
+    processExecutionId: peBundle.processExecutionId,
+    startResponse: {
+      planId: started.planId,
+      taskId: started.taskId,
+      path: 'workHub',
+      planAttempts: started.attempt
+    },
+    finalStatus: {
+      status: taskStatus === 'completed' ? 'completed' : taskStatus || 'stopped',
+      wait: null
+    },
+    timeline: pollState.timeline,
+    interactions: pollState.interactions,
+    workResult: peBundle.workResult,
+    workResultError: peBundle.workResultError
+  };
+}
+
+async function runWorkHubCaseLifecycle(roleKey, testCase, runtimeContext, options = {}) {
+  const dataplaneUrl = runtimeContext?.dataplaneUrl;
+  const authConfig = runtimeContext?.authConfig;
+  const objective = resolveObjective(testCase);
+  if (!objective) {
+    throw new Error(
+      `Role assistant Work Hub case "${testCase.caseId}" is missing input.message/objective.`
+    );
+  }
+  const input = resolveInput(testCase);
+  const assistantName = String(
+    input.assistantName || input.digitalWorkerKey || roleKey
+  ).trim();
+  const planBody = {
+    objective,
+    digitalWorkerKey: String(input.digitalWorkerKey || roleKey).trim()
+  };
+  const started = await createActivateAcceptPlan(
+    dataplaneUrl,
+    authConfig,
+    planBody,
+    assistantName,
+    options
+  );
+  const pollState = await pollWorkHubTask(
+    dataplaneUrl,
+    authConfig,
+    started.taskId,
+    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);
+}
+
+module.exports = {
+  wantsWorkHubPath,
+  runWorkHubCaseLifecycle,
+  planAlreadyActivated,
+  isPlanLostError,
+  extractPeFromTask,
+  synthesizeWaitAnswer,
+  isApprovalNotPendingError
+};