@workglow/test-contract 0.6.1

package/dist/human-connector.js

@@ -0,0 +1,843 @@
+// src/human-connector/MockHumanConnector.ts
+class Script {
+  _received = [];
+  _queue = [];
+  _pendingDeferreds = [];
+  get received() {
+    return this._received;
+  }
+  recordReceived(req) {
+    this._received.push(req);
+  }
+  push(entry) {
+    this._queue.push({ kind: "immediate", entry });
+  }
+  pushDeferred() {
+    const def = {
+      kind: "deferred",
+      resolved: { value: undefined },
+      settled: { done: false },
+      waiters: [],
+      rejecters: []
+    };
+    this._queue.push(def);
+    this._pendingDeferreds.push(def);
+    return {
+      release: (response) => {
+        if (def.settled.done)
+          return;
+        def.settled.done = true;
+        def.resolved.value = response;
+        for (const w of def.waiters)
+          w(response);
+        def.waiters.length = 0;
+        def.rejecters.length = 0;
+      }
+    };
+  }
+  shift() {
+    return this._queue.shift();
+  }
+  clear() {
+    for (const def of this._pendingDeferreds) {
+      if (def.settled.done)
+        continue;
+      def.settled.done = true;
+      const err = new Error("MockHumanConnector script cleared while deferred was pending");
+      err.name = "AbortError";
+      for (const r of def.rejecters)
+        r(err);
+      def.rejecters.length = 0;
+      def.waiters.length = 0;
+    }
+    this._pendingDeferreds.length = 0;
+    this._received.length = 0;
+    this._queue.length = 0;
+  }
+}
+function defaultAbortError(signal) {
+  if (signal.reason instanceof Error)
+    return signal.reason;
+  const err = new Error("The operation was aborted");
+  err.name = "AbortError";
+  return err;
+}
+function awaitDeferred(def, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal.aborted) {
+      reject(defaultAbortError(signal));
+      return;
+    }
+    if (def.settled.done && def.resolved.value !== undefined) {
+      resolve(def.resolved.value);
+      return;
+    }
+    const onAbort = () => {
+      signal.removeEventListener("abort", onAbort);
+      reject(defaultAbortError(signal));
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+    def.waiters.push((res) => {
+      signal.removeEventListener("abort", onAbort);
+      resolve(res);
+    });
+    def.rejecters.push((err) => {
+      signal.removeEventListener("abort", onAbort);
+      reject(err);
+    });
+  });
+}
+
+class MockHumanConnector {
+  defaultAction;
+  _script;
+  followUp;
+  constructor(opts = {}) {
+    this.defaultAction = opts.defaultAction ?? "accept";
+    this._script = new Script;
+    if (opts.supportsFollowUp ?? true) {
+      this.followUp = (request, _previous, signal) => this.send(request, signal);
+    }
+  }
+  get script() {
+    return this._script;
+  }
+  async send(request, signal) {
+    if (signal.aborted)
+      throw defaultAbortError(signal);
+    this._script.recordReceived(request);
+    if (request.kind === "notify" || request.kind === "display") {
+      return {
+        requestId: request.requestId,
+        action: this.defaultAction,
+        content: undefined,
+        done: true
+      };
+    }
+    const entry = this._script.shift();
+    if (entry === undefined) {
+      return {
+        requestId: request.requestId,
+        action: this.defaultAction,
+        content: undefined,
+        done: true
+      };
+    }
+    if (entry.kind === "deferred") {
+      const res = await awaitDeferred(entry, signal);
+      return this.shape(request, res);
+    }
+    const resolved = typeof entry.entry === "function" ? await entry.entry(request) : entry.entry;
+    return this.shape(request, resolved);
+  }
+  shape(request, response) {
+    const carriesContent = request.kind === "elicit" && response.action === "accept";
+    return {
+      ...response,
+      requestId: request.requestId,
+      content: carriesContent ? response.content : undefined
+    };
+  }
+}
+// src/human-connector/fixtures.ts
+var elicitSchema = {
+  type: "object",
+  properties: {
+    approved: {
+      type: "boolean",
+      title: "Approved",
+      description: "Whether the request is approved"
+    },
+    reason: { type: "string", title: "Reason" }
+  },
+  required: ["approved"],
+  additionalProperties: false
+};
+var emptySchema = {
+  type: "object",
+  properties: {},
+  additionalProperties: true
+};
+var DEFAULT_HUMAN_CONFORMANCE_FIXTURE = {
+  elicitContentSchema: elicitSchema,
+  elicitAcceptContent: { approved: true, reason: "looks good" },
+  notifyRequest: {
+    message: "Job completed.",
+    contentSchema: emptySchema,
+    contentData: { jobId: "test-1" }
+  },
+  displayRequest: {
+    message: "Here is the result.",
+    contentSchema: emptySchema,
+    contentData: { result: 42 }
+  },
+  confirmRequest: {
+    message: 'Run workflow "nightly-export"?',
+    contentSchema: {
+      type: "object",
+      properties: {
+        action: { type: "string", title: "Action" },
+        reaches: { type: "string", title: "Reaches" }
+      },
+      additionalProperties: true
+    },
+    contentData: { action: "Run workflow", reaches: "network:http → https://example.test" }
+  },
+  abortGraceMs: 1000
+};
+function resolveHumanConformanceFixture(override) {
+  if (!override)
+    return DEFAULT_HUMAN_CONFORMANCE_FIXTURE;
+  return { ...DEFAULT_HUMAN_CONFORMANCE_FIXTURE, ...override };
+}
+// src/human-connector/runHumanConnectorConformance.ts
+import { afterAll, beforeAll, beforeEach, describe as describe7 } from "vitest";
+
+// src/human-connector/assertions/abort.ts
+import { describe, expect, it as it2 } from "vitest";
+
+// src/creditExhaustedSkip.ts
+import { it as vitestIt } from "vitest";
+var BILLING_CODES = new Set([
+  "insufficient_quota",
+  "billing_hard_limit_reached",
+  "insufficient_credits",
+  "insufficient_balance"
+]);
+var CREDIT_MESSAGE = /insufficient credits|not enough credits|no credits remaining|out of credits|insufficient[\s_-]balance|balance is (?:too low|insufficient)|exceeded[\s\S]{0,80}credits|monthly included credits|payment required|exceeded your current quota|check your plan and billing|billing_hard_limit/i;
+var HTTP_402_MESSAGE = /\bHTTP\/?\d?(?:\.\d)?\s*402\b|\bstatus(?:\s*code)?\s*[:=]\s*402\b|\berror code:?\s*402\b|(?:^|:\s+)402\s+[a-z]/im;
+function isCreditExhaustedError(err) {
+  const seen = new Set;
+  let current = err;
+  while (current !== undefined && current !== null && !seen.has(current)) {
+    seen.add(current);
+    if (matchesCreditExhaustion(current))
+      return true;
+    current = causeOf(current);
+  }
+  return false;
+}
+function matchesCreditExhaustion(err) {
+  if (typeof err === "string")
+    return messageLooksLikeCreditExhaustion(err);
+  if (!err || typeof err !== "object")
+    return false;
+  const rec = err;
+  const status = numericStatus(rec);
+  if (status === 402)
+    return true;
+  const code = stringish(rec.code) ?? stringish(nested(rec.error, "code"));
+  const type = stringish(rec.type) ?? stringish(nested(rec.error, "type"));
+  if (code && BILLING_CODES.has(code))
+    return true;
+  if (type && BILLING_CODES.has(type))
+    return true;
+  const message = [
+    stringish(rec.message),
+    stringish(nested(rec.error, "message")),
+    stringifyUnknown(err)
+  ].filter((part) => typeof part === "string").join(`
+`);
+  return messageLooksLikeCreditExhaustion(message);
+}
+function messageLooksLikeCreditExhaustion(message) {
+  return CREDIT_MESSAGE.test(message) || HTTP_402_MESSAGE.test(message);
+}
+function numericStatus(rec) {
+  for (const key of ["status", "statusCode"]) {
+    const value = rec[key];
+    if (typeof value === "number" && Number.isFinite(value))
+      return value;
+  }
+  const nestedStatus = nested(rec.error, "status");
+  if (typeof nestedStatus === "number" && Number.isFinite(nestedStatus))
+    return nestedStatus;
+  return;
+}
+function nested(value, key) {
+  if (!value || typeof value !== "object")
+    return;
+  return value[key];
+}
+function stringish(value) {
+  return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function stringifyUnknown(err) {
+  if (err instanceof Error)
+    return err.message;
+  return String(err);
+}
+function causeOf(err) {
+  if (!err || typeof err !== "object")
+    return;
+  return err.cause;
+}
+function creditSkipNote(err) {
+  const message = err instanceof Error ? err.message : String(err);
+  return `skipped: provider out of credits (${message})`;
+}
+var SKIP_OVERRIDE_ENV = "WORKGLOW_CREDIT_EXHAUSTED_SKIP";
+function isTruthyFlag(value) {
+  return !/^(?:0|false|off|no)$/i.test(value.trim());
+}
+function creditExhaustionSkipsTest(env = process.env) {
+  const override = env[SKIP_OVERRIDE_ENV];
+  if (override !== undefined && override.trim() !== "")
+    return isTruthyFlag(override);
+  for (const key of ["CI", "GITHUB_ACTIONS"]) {
+    const value = env[key];
+    if (value !== undefined && value.trim() !== "" && isTruthyFlag(value))
+      return true;
+  }
+  return false;
+}
+function reportLocalCreditFailure(err) {
+  const message = err instanceof Error ? err.message : String(err);
+  console.error(`provider out of credits (${message})
+` + `  Failing because this is not CI. Top the account up, or set ${SKIP_OVERRIDE_ENV}=1 to skip instead.`);
+}
+async function runWithCreditSkip(ctx, fn) {
+  try {
+    return await fn();
+  } catch (err) {
+    if (isCreditExhaustedError(err)) {
+      if (!creditExhaustionSkipsTest()) {
+        reportLocalCreditFailure(err);
+        throw err;
+      }
+      ctx.skip(creditSkipNote(err));
+      return;
+    }
+    throw err;
+  }
+}
+function wrapTestBodyForCreditSkip(fn) {
+  return async function wrapped(...args) {
+    try {
+      return await fn.apply(this, args);
+    } catch (err) {
+      if (!isCreditExhaustedError(err))
+        throw err;
+      if (!creditExhaustionSkipsTest()) {
+        reportLocalCreditFailure(err);
+        throw err;
+      }
+      const ctx = args[0];
+      if (ctx && typeof ctx.skip === "function") {
+        ctx.skip(creditSkipNote(err));
+        return;
+      }
+      console.warn(creditSkipNote(err));
+      return;
+    }
+  };
+}
+function wrapCallable(fn) {
+  return new Proxy(fn, {
+    apply(target, thisArg, argArray) {
+      const wrapped = argArray.map((arg) => typeof arg === "function" ? wrapTestBodyForCreditSkip(arg) : arg);
+      const result = Reflect.apply(target, thisArg, wrapped);
+      return typeof result === "function" ? wrapCallable(result) : result;
+    },
+    get(target, prop, receiver) {
+      const value = Reflect.get(target, prop, receiver);
+      if (typeof value === "function") {
+        return wrapCallable(value.bind(target));
+      }
+      return value;
+    }
+  });
+}
+var it = wrapCallable(vitestIt);
+
+// src/itExpectFail.ts
+var itExpectFail = (name, fn, timeout) => {
+  const native = it.fails;
+  if (typeof native === "function") {
+    native(name, fn, timeout);
+    return;
+  }
+  it(`${name} [expected-fail]`, async () => {
+    let passed = false;
+    try {
+      await fn();
+      passed = true;
+    } catch (err) {
+      if (isCreditExhaustedError(err))
+        throw err;
+    }
+    if (passed) {
+      throw new Error(`Test "${name}" was marked as expected-fail but passed. Remove its name from opts.expectedFailures.`);
+    }
+  }, timeout);
+};
+
+// src/human-connector/assertions/abort.ts
+function isAbortError(err) {
+  if (!err || typeof err !== "object")
+    return false;
+  const e = err;
+  return e.name === "AbortError" || /abort/i.test(e.message ?? "");
+}
+function elicitReq(fixture, requestId) {
+  return {
+    requestId,
+    targetHumanId: "default",
+    kind: "elicit",
+    message: "Please confirm.",
+    contentSchema: fixture.elicitContentSchema,
+    contentData: undefined,
+    expectsResponse: true,
+    mode: "single",
+    metadata: undefined
+  };
+}
+function abortBlock(opts, fixture, getHandle) {
+  const expectFails = new Set(opts.expectedFailures ?? []);
+  const itBefore = expectFails.has("abort.beforeSend") ? itExpectFail : it2;
+  const itMid = expectFails.has("abort.midElicit") ? itExpectFail : it2;
+  describe.skipIf(!opts.capabilities.elicit)("Abort", () => {
+    itBefore("send() with already-aborted signal rejects with AbortError", async () => {
+      const { connector } = getHandle();
+      const ac = new AbortController;
+      ac.abort();
+      let caught;
+      try {
+        await connector.send(elicitReq(fixture, "ab-pre-1"), ac.signal);
+      } catch (err) {
+        caught = err;
+      }
+      expect(caught).toBeDefined();
+      expect(isAbortError(caught)).toBe(true);
+    }, opts.timeout);
+    if (opts.capabilities.abortMidElicit) {
+      itMid("send() rejects with AbortError when signal aborts mid-elicit", async () => {
+        const { connector, script } = getHandle();
+        const handle = script.pushDeferred();
+        const ac = new AbortController;
+        const start = Date.now();
+        const promise = connector.send(elicitReq(fixture, "ab-mid-1"), ac.signal);
+        setTimeout(() => ac.abort(), 25);
+        let caught;
+        try {
+          await promise;
+        } catch (err) {
+          caught = err;
+        }
+        const elapsed = Date.now() - start;
+        expect(caught).toBeDefined();
+        expect(isAbortError(caught)).toBe(true);
+        expect(elapsed).toBeLessThan(fixture.abortGraceMs * 4 + 2000);
+        expect(() => handle.release({
+          requestId: "x",
+          action: "accept",
+          content: undefined,
+          done: true
+        })).not.toThrow();
+      }, opts.timeout);
+    }
+  });
+}
+
+// src/human-connector/assertions/capabilityHonesty.ts
+import { describe as describe2, expect as expect2, it as it3 } from "vitest";
+function buildReq(fixture, kind, requestId) {
+  const base = kind === "elicit" ? { message: "elicit", contentSchema: fixture.elicitContentSchema, contentData: undefined } : kind === "notify" ? fixture.notifyRequest : kind === "confirm" ? fixture.confirmRequest : fixture.displayRequest;
+  return {
+    requestId,
+    targetHumanId: "default",
+    kind,
+    message: base.message,
+    contentSchema: base.contentSchema,
+    contentData: base.contentData,
+    expectsResponse: kind === "elicit" || kind === "confirm",
+    mode: "single",
+    metadata: undefined
+  };
+}
+function capabilityHonestyBlock(opts, fixture, getHandle) {
+  const expectFails = new Set(opts.expectedFailures ?? []);
+  const itFn = expectFails.has("capabilityHonesty") ? itExpectFail : it3;
+  describe2("Capability honesty", () => {
+    itFn("multiTurn:false implies followUp is undefined (not silent no-op)", () => {
+      if (opts.capabilities.multiTurn)
+        return;
+      const { connector } = getHandle();
+      expect2(connector.followUp).toBeUndefined();
+    }, opts.timeout);
+    for (const kind of ["notify", "display", "elicit", "confirm"]) {
+      itFn(`${kind}:false implies the connector either throws or surfaces a non-accept action (no silent accept)`, async () => {
+        if (opts.capabilities[kind])
+          return;
+        const { connector } = getHandle();
+        const ac = new AbortController;
+        let caught;
+        let res;
+        try {
+          res = await connector.send(buildReq(fixture, kind, `cap-${kind}`), ac.signal);
+        } catch (err) {
+          caught = err;
+        }
+        if (caught) {
+          expect2(caught).toBeDefined();
+          return;
+        }
+        expect2(res).toBeDefined();
+        expect2(res.action).not.toBe("accept");
+      }, opts.timeout);
+    }
+  });
+}
+
+// src/human-connector/assertions/concurrentIsolation.ts
+import { describe as describe3, expect as expect3, it as it4 } from "vitest";
+function elicitReq2(fixture, requestId) {
+  return {
+    requestId,
+    targetHumanId: "default",
+    kind: "elicit",
+    message: `Please confirm ${requestId}.`,
+    contentSchema: fixture.elicitContentSchema,
+    contentData: undefined,
+    expectsResponse: true,
+    mode: "single",
+    metadata: undefined
+  };
+}
+function concurrentIsolationBlock(opts, fixture, getHandle) {
+  const expectFails = new Set(opts.expectedFailures ?? []);
+  const itConcurrent = expectFails.has("concurrent.isolation") ? itExpectFail : it4;
+  describe3.skipIf(!opts.capabilities.concurrent || !opts.capabilities.elicit)("Concurrent isolation", () => {
+    itConcurrent("two concurrent send() calls each receive their own scripted response", async () => {
+      const { connector, script } = getHandle();
+      const tagFromMessage = (message) => {
+        const m = message.match(/Please confirm (.+)\./);
+        return m ? m[1] : "unknown";
+      };
+      script.push((req) => {
+        const tag = tagFromMessage(req.message);
+        return {
+          requestId: req.requestId,
+          action: "accept",
+          content: { approved: true, reason: tag },
+          done: true
+        };
+      });
+      script.push((req) => {
+        const tag = tagFromMessage(req.message);
+        return {
+          requestId: req.requestId,
+          action: "accept",
+          content: { approved: true, reason: tag },
+          done: true
+        };
+      });
+      const ac = new AbortController;
+      const p1 = connector.send(elicitReq2(fixture, "conc-A"), ac.signal);
+      const p2 = connector.send(elicitReq2(fixture, "conc-B"), ac.signal);
+      const [a, b] = await Promise.all([p1, p2]);
+      expect3(a.requestId).toBe("conc-A");
+      expect3(a.content.reason).toBe("conc-A");
+      expect3(b.requestId).toBe("conc-B");
+      expect3(b.content.reason).toBe("conc-B");
+    }, opts.timeout);
+  });
+}
+
+// src/human-connector/assertions/multiTurnFollowUp.ts
+import { describe as describe4, expect as expect4, it as it5 } from "vitest";
+function elicitReq3(fixture, requestId, mode) {
+  return {
+    requestId,
+    targetHumanId: "default",
+    kind: "elicit",
+    message: "Multi-turn step.",
+    contentSchema: fixture.elicitContentSchema,
+    contentData: undefined,
+    expectsResponse: true,
+    mode,
+    metadata: undefined
+  };
+}
+function isAbortError2(err) {
+  if (!err || typeof err !== "object")
+    return false;
+  const e = err;
+  return e.name === "AbortError" || /abort/i.test(e.message ?? "");
+}
+function multiTurnFollowUpBlock(opts, fixture, getHandle) {
+  const expectFails = new Set(opts.expectedFailures ?? []);
+  const itFn = expectFails.has("multiTurn.followUp") ? itExpectFail : it5;
+  describe4.skipIf(!opts.capabilities.multiTurn || !opts.capabilities.elicit)("Multi-turn followUp", () => {
+    itFn("followUp() called after done=false response returns terminal response", async () => {
+      const { connector, script } = getHandle();
+      script.push({
+        requestId: "x",
+        action: "accept",
+        content: { approved: false, reason: "step1" },
+        done: false
+      });
+      script.push({
+        requestId: "x",
+        action: "accept",
+        content: { approved: true, reason: "step2" },
+        done: true
+      });
+      const ac = new AbortController;
+      const req = elicitReq3(fixture, "mt-1", "multi-turn");
+      const first = await connector.send(req, ac.signal);
+      expect4(first.done).toBe(false);
+      expect4(typeof connector.followUp).toBe("function");
+      const second = await connector.followUp(req, first, ac.signal);
+      expect4(second.done).toBe(true);
+      expect4(second.content).toEqual({ approved: true, reason: "step2" });
+    }, opts.timeout);
+    if (opts.capabilities.abortMidElicit) {
+      itFn("followUp() honors AbortSignal mid-flight", async () => {
+        const { connector, script } = getHandle();
+        script.push({
+          requestId: "x",
+          action: "accept",
+          content: { approved: false, reason: "step1" },
+          done: false
+        });
+        script.pushDeferred();
+        const ac = new AbortController;
+        const req = elicitReq3(fixture, "mt-2", "multi-turn");
+        const first = await connector.send(req, ac.signal);
+        expect4(first.done).toBe(false);
+        const promise = connector.followUp(req, first, ac.signal);
+        setTimeout(() => ac.abort(), 25);
+        let caught;
+        try {
+          await promise;
+        } catch (err) {
+          caught = err;
+        }
+        expect4(caught).toBeDefined();
+        expect4(isAbortError2(caught)).toBe(true);
+      }, opts.timeout);
+    }
+  });
+}
+
+// src/human-connector/assertions/notifyDisplayFastResolve.ts
+import { describe as describe5, expect as expect5, it as it6 } from "vitest";
+function buildReq2(fixture, kind, requestId) {
+  const base = kind === "notify" ? fixture.notifyRequest : fixture.displayRequest;
+  return {
+    requestId,
+    targetHumanId: "default",
+    kind,
+    message: base.message,
+    contentSchema: base.contentSchema,
+    contentData: base.contentData,
+    expectsResponse: false,
+    mode: "single",
+    metadata: undefined
+  };
+}
+function elicitReq4(fixture, requestId) {
+  return {
+    requestId,
+    targetHumanId: "default",
+    kind: "elicit",
+    message: "Follow-up after fast-resolve.",
+    contentSchema: fixture.elicitContentSchema,
+    contentData: undefined,
+    expectsResponse: true,
+    mode: "single",
+    metadata: undefined
+  };
+}
+function block(kind, enabled, failId, opts, fixture, getHandle) {
+  const expectFails = new Set(opts.expectedFailures ?? []);
+  const itFn = expectFails.has(failId) ? itExpectFail : it6;
+  describe5.skipIf(!enabled || !opts.capabilities.elicit)(`${kind} fast-resolve`, () => {
+    itFn(`${kind} resolves with action=accept, done=true, and does not consume scripted elicit responses`, async () => {
+      const { connector, script } = getHandle();
+      const sentinel = { approved: true, reason: "sentinel" };
+      script.push({ requestId: "ignored", action: "accept", content: sentinel, done: true });
+      const ac = new AbortController;
+      const res = await connector.send(buildReq2(fixture, kind, `${kind}-1`), ac.signal);
+      expect5(res.action).toBe("accept");
+      expect5(res.done).toBe(true);
+      expect5(res.content).toBeUndefined();
+      const elicitRes = await connector.send(elicitReq4(fixture, `${kind}-elicit-1`), ac.signal);
+      expect5(elicitRes.action).toBe("accept");
+      expect5(elicitRes.content).toEqual(sentinel);
+      expect5(elicitRes.requestId).toBe(`${kind}-elicit-1`);
+    }, opts.timeout);
+  });
+}
+function notifyDisplayFastResolveBlock(opts, fixture, getHandle) {
+  block("notify", opts.capabilities.notify, "notify.fastResolve", opts, fixture, getHandle);
+  block("display", opts.capabilities.display, "display.fastResolve", opts, fixture, getHandle);
+}
+
+// src/human-connector/assertions/roundtrip.ts
+import { describe as describe6, expect as expect6, it as it7 } from "vitest";
+function elicitReq5(fixture, requestId) {
+  return {
+    requestId,
+    targetHumanId: "default",
+    kind: "elicit",
+    message: "Please confirm.",
+    contentSchema: fixture.elicitContentSchema,
+    contentData: undefined,
+    expectsResponse: true,
+    mode: "single",
+    metadata: undefined
+  };
+}
+function confirmReq(fixture, requestId) {
+  return {
+    requestId,
+    targetHumanId: "default",
+    kind: "confirm",
+    message: fixture.confirmRequest.message,
+    contentSchema: fixture.confirmRequest.contentSchema,
+    contentData: fixture.confirmRequest.contentData,
+    expectsResponse: true,
+    mode: "single",
+    metadata: undefined
+  };
+}
+function roundtripBlock(opts, fixture, getHandle) {
+  const expectFails = new Set(opts.expectedFailures ?? []);
+  const itAccept = expectFails.has("roundtrip.accept") ? itExpectFail : it7;
+  const itDecline = expectFails.has("roundtrip.decline") ? itExpectFail : it7;
+  const itCancel = expectFails.has("roundtrip.cancel") ? itExpectFail : it7;
+  const itConfirmAccept = expectFails.has("roundtrip.confirm.accept") ? itExpectFail : it7;
+  const itConfirmDecline = expectFails.has("roundtrip.confirm.decline") ? itExpectFail : it7;
+  const itConfirmDetails = expectFails.has("roundtrip.confirm.details") ? itExpectFail : it7;
+  const itConfirmNoContent = expectFails.has("roundtrip.confirm.noContent") ? itExpectFail : it7;
+  describe6.skipIf(!opts.capabilities.elicit)("Roundtrip elicit", () => {
+    itAccept("accept echoes requestId, returns done=true, surfaces content", async () => {
+      const { connector, script } = getHandle();
+      script.push({
+        requestId: "ignored",
+        action: "accept",
+        content: fixture.elicitAcceptContent,
+        done: true
+      });
+      const ac = new AbortController;
+      const res = await connector.send(elicitReq5(fixture, "rt-accept-1"), ac.signal);
+      expect6(res.requestId).toBe("rt-accept-1");
+      expect6(res.action).toBe("accept");
+      expect6(res.done).toBe(true);
+      expect6(res.content).toEqual(fixture.elicitAcceptContent);
+    }, opts.timeout);
+    itDecline("decline surfaces with content=undefined, no throw", async () => {
+      const { connector, script } = getHandle();
+      script.push({ requestId: "x", action: "decline", content: undefined, done: true });
+      const ac = new AbortController;
+      const res = await connector.send(elicitReq5(fixture, "rt-dec-1"), ac.signal);
+      expect6(res.requestId).toBe("rt-dec-1");
+      expect6(res.action).toBe("decline");
+      expect6(res.done).toBe(true);
+      expect6(res.content).toBeUndefined();
+    }, opts.timeout);
+    itCancel("cancel surfaces with content=undefined, no throw", async () => {
+      const { connector, script } = getHandle();
+      script.push({ requestId: "x", action: "cancel", content: undefined, done: true });
+      const ac = new AbortController;
+      const res = await connector.send(elicitReq5(fixture, "rt-can-1"), ac.signal);
+      expect6(res.requestId).toBe("rt-can-1");
+      expect6(res.action).toBe("cancel");
+      expect6(res.done).toBe(true);
+      expect6(res.content).toBeUndefined();
+    }, opts.timeout);
+  });
+  describe6.skipIf(!opts.capabilities.confirm)("Roundtrip confirm", () => {
+    itConfirmAccept("a decision reaches the caller as the person's own answer", async () => {
+      const { connector, script } = getHandle();
+      script.push({ requestId: "x", action: "accept", content: undefined, done: true });
+      const ac = new AbortController;
+      const res = await connector.send(confirmReq(fixture, "rt-confirm-accept"), ac.signal);
+      expect6(res.requestId).toBe("rt-confirm-accept");
+      expect6(res.action).toBe("accept");
+      expect6(res.done).toBe(true);
+    }, opts.timeout);
+    itConfirmDecline("a refusal is a refusal, not an unanswered accept", async () => {
+      const { connector, script } = getHandle();
+      script.push({ requestId: "x", action: "decline", content: undefined, done: true });
+      const ac = new AbortController;
+      const res = await connector.send(confirmReq(fixture, "rt-confirm-decline"), ac.signal);
+      expect6(res.requestId).toBe("rt-confirm-decline");
+      expect6(res.action).toBe("decline");
+      expect6(res.done).toBe(true);
+    }, opts.timeout);
+    itConfirmNoContent("an accepted confirm answers with the decision and nothing else", async () => {
+      const { connector, script } = getHandle();
+      script.push({
+        requestId: "x",
+        action: "accept",
+        content: { action: "something else" },
+        done: true
+      });
+      const ac = new AbortController;
+      const res = await connector.send(confirmReq(fixture, "rt-confirm-content"), ac.signal);
+      expect6(res.action).toBe("accept");
+      expect6(res.content).toBeUndefined();
+    }, opts.timeout);
+    itConfirmDetails("the action's details reach the person deciding", async () => {
+      const { connector, script } = getHandle();
+      script.push({ requestId: "x", action: "decline", content: undefined, done: true });
+      const ac = new AbortController;
+      await connector.send(confirmReq(fixture, "rt-confirm-details"), ac.signal);
+      const received = script.received.at(-1);
+      const shown = JSON.stringify({
+        message: received?.message,
+        contentData: received?.contentData
+      });
+      for (const value of Object.values(fixture.confirmRequest.contentData ?? {})) {
+        if (typeof value === "string")
+          expect6(shown).toContain(value);
+      }
+    }, opts.timeout);
+  });
+}
+
+// src/human-connector/runHumanConnectorConformance.ts
+function runHumanConnectorConformance(opts) {
+  describe7.skipIf(opts.skip)(`IHumanConnector conformance: ${opts.name}`, () => {
+    let handle;
+    const getHandle = () => {
+      if (!handle)
+        throw new Error("conformance handle not initialized");
+      return handle;
+    };
+    beforeAll(async () => {
+      handle = await opts.factory();
+    }, opts.timeout);
+    beforeEach(() => {
+      handle?.script.clear();
+    });
+    afterAll(async () => {
+      if (handle)
+        await handle.dispose();
+    });
+    const fixture = resolveHumanConformanceFixture(opts.fixture);
+    roundtripBlock(opts, fixture, getHandle);
+    abortBlock(opts, fixture, getHandle);
+    concurrentIsolationBlock(opts, fixture, getHandle);
+    notifyDisplayFastResolveBlock(opts, fixture, getHandle);
+    multiTurnFollowUpBlock(opts, fixture, getHandle);
+    capabilityHonestyBlock(opts, fixture, getHandle);
+  });
+}
+export {
+  DEFAULT_HUMAN_CONFORMANCE_FIXTURE,
+  MockHumanConnector,
+  abortBlock,
+  capabilityHonestyBlock,
+  concurrentIsolationBlock,
+  multiTurnFollowUpBlock,
+  notifyDisplayFastResolveBlock,
+  resolveHumanConformanceFixture,
+  roundtripBlock,
+  runHumanConnectorConformance
+};
+
+//# debugId=1244A5B943D10CD864756E2164756E21