Function runCase

e2e/run.ts:89–324

(spec: E2ECase)

}

async function runCase(spec: E2ECase): Promise<CaseResult> {
  const errors: string[] = [];
  const samples: CaseResult["samples"] = [];
  const t0 = Date.now();

  // Mark "now" in the channel timeline so we know which bot replies are ours.
  const beforeHist = await channelHistory(TEST_CHANNEL, 1);
  const sinceTs = beforeHist[0]?.ts ?? "0";

  // Send the prompt as Atai.
  const sent = await postAsUser(TEST_CHANNEL, spec.prompt);
  const parentTs = (sent as { ts?: string }).ts ?? "";
  if (!parentTs) errors.push("postAsUser returned no ts");

  // The bot's reply for an @mention goes into a thread off parentTs; for
  // a /agent slash command it lands flat in the channel. We can't tell
  // from the prompt alone — try the thread first, then fall back to flat.
  const flatMode = /^\/agent\b/.test(spec.prompt);
  const sampleIntervalMs = spec.sampleIntervalMs ?? 1000;
  const maxWaitMs = spec.maxWaitMs ?? 30_000;
  let followUpResult: CaseResult | undefined;

  // Schedule a mid-stream interrupt if the case asks for one.
  let interruptTimer: NodeJS.Timeout | undefined;
  if (spec.interrupt && parentTs) {
    interruptTimer = setTimeout(() => {
      postAsUser(TEST_CHANNEL, spec.interrupt!.prompt, {
        threadTs: parentTs,
      }).catch((e: Error) =>
        errors.push(`interrupt send failed: ${e.message}`),
      );
    }, spec.interrupt.afterMs);
  }

  const onSample = (s: { elapsedMs: number; text: string | undefined }) => {
    const text = s.text ?? "";
    const balanced = isBalanced(text);
    samples.push({
      elapsedMs: s.elapsedMs,
      balanced,
      len: text.length,
      preview: text.slice(0, 100),
      // Capture full text for unbalanced samples so we can diagnose without
      // having to re-run. Skipped for balanced samples to keep reports small.
      ...(text.length > 0 && !balanced ? { full: text } : {}),
    });
  };

  if (interruptTimer === undefined) {
    /* no-op */
  }
  const result = flatMode
    ? await watchForChannelReply({
        channel: TEST_CHANNEL,
        sinceTs,
        intervalMs: sampleIntervalMs,
        timeoutMs: maxWaitMs,
        onSample,