@cohortapp/agent-sdk 2.17.0 → 2.18.4

package/lib/org/typing.test.mjs

@@ -1,291 +0,0 @@
-/**
- * typing.test.mjs — the agent-side "is composing…" indicator.
- *
- * Two units, both hermetic:
- *   - emitTyping: params/URL/headers on the wire, the enrolment short-circuit,
- *     and fail-open on an error frame (never throws, never claims ok).
- *   - the adapter: immediate first beat, re-assert cadence adopted from the
- *     server, idempotent start, stop clears the indicator, and — the property
- *     that keeps this out of the session path — a permanently failing server
- *     produces exactly one log line per throttle window, not one per beat.
- *
- * Uses an injected fetchImpl / emit + injected timers — no network, no clocks.
- * Run: node --test lib/org/typing.test.mjs
- */
-"use strict";
-
-import { test } from "node:test";
-import assert from "node:assert/strict";
-
-import {
-  emitTyping,
-  createCohortTypingAdapter,
-  cohortTypingAdapter,
-  resetCohortTypingAdapter,
-  resetTypingConfigCache,
-  DEFAULT_INTERVAL_MS,
-  MAX_INTERVAL_MS,
-  MIN_INTERVAL_MS,
-  LOG_THROTTLE_MS,
-} from "./typing.mjs";
-
-const BASE = "https://os.cohortapp.com";
-const CFG = { org: { cohort: { enabled: true, base: BASE, token: "tok", orgId: "adaptic" } } };
-const OFF = { org: { cohort: { enabled: false } } };
-
-delete process.env.COHORT_API_TOKEN;
-delete process.env.COHORT_TOKEN;
-
-/** A fake fetch that records calls and returns a canned res frame. */
-function fakeFetch(responder) {
-  const calls = [];
-  const impl = async (url, init) => {
-    calls.push({
-      url,
-      method: init && init.method,
-      headers: (init && init.headers) || {},
-      body: init && init.body ? JSON.parse(init.body) : null,
-    });
-    const r = responder ? responder(url, init, calls.length - 1) : null;
-    const status = r && typeof r.status === "number" ? r.status : 200;
-    const ok = r && typeof r.ok === "boolean" ? r.ok : status >= 200 && status < 300;
-    const body = r ? r.body : { ok: true, result: { ok: true, refreshAfterMs: 3000 } };
-    return { ok, status, headers: { get: () => undefined }, json: async () => body };
-  };
-  impl.calls = calls;
-  return impl;
-}
-
-/** Controllable interval timers. */
-function fakeTimers() {
-  const timers = new Map();
-  let next = 1;
-  return {
-    timers,
-    setInterval: (fn, ms) => {
-      const id = next++;
-      timers.set(id, { fn, ms });
-      return id;
-    },
-    clearInterval: (id) => timers.delete(id),
-    /** Fire every registered interval once. */
-    async tick() {
-      for (const t of [...timers.values()]) t.fn();
-      await new Promise((r) => setImmediate(r));
-    },
-  };
-}
-
-// --- emitTyping -------------------------------------------------------------
-
-test("emitTyping: posts messaging.typing with channelId + state, bearer + org pin", async () => {
-  const f = fakeFetch();
-  const r = await emitTyping({ channelId: "ch_1", cfg: CFG, fetchImpl: f });
-
-  assert.equal(r.ok, true);
-  assert.equal(r.refreshAfterMs, 3000);
-  assert.equal(f.calls.length, 1);
-  assert.equal(f.calls[0].url, `${BASE}/api/v1/messaging.typing`);
-  assert.equal(f.calls[0].method, "POST");
-  assert.equal(f.calls[0].headers.authorization, "Bearer tok");
-  assert.equal(f.calls[0].headers["x-org-id"], "adaptic");
-  assert.deepEqual(f.calls[0].body, { channelId: "ch_1", state: true });
-});
-
-test("emitTyping: threadRootId rides through; state:false is a stop", async () => {
-  const f = fakeFetch();
-  await emitTyping({ channelId: "ch_1", threadRootId: "msg_root", state: false, cfg: CFG, fetchImpl: f });
-  assert.deepEqual(f.calls[0].body, { channelId: "ch_1", state: false, threadRootId: "msg_root" });
-});
-
-test("emitTyping: no channelId and un-enrolled both skip WITHOUT a request", async () => {
-  const f = fakeFetch();
-  const noChannel = await emitTyping({ cfg: CFG, fetchImpl: f });
-  assert.equal(noChannel.ok, false);
-  assert.equal(noChannel.skipped, true);
-
-  const off = await emitTyping({ channelId: "ch_1", cfg: OFF, fetchImpl: f });
-  assert.equal(off.ok, false);
-  assert.equal(off.skipped, true);
-
-  assert.equal(f.calls.length, 0);
-});
-
-test("emitTyping: an error frame fails open (no throw) and is NOT reported as skipped", async () => {
-  const f = fakeFetch(() => ({ status: 403, body: { ok: false, error: { code: "FORBIDDEN_SCOPE", message: "not a member" } } }));
-  const r = await emitTyping({ channelId: "ch_1", cfg: CFG, fetchImpl: f });
-  assert.equal(r.ok, false);
-  assert.equal(r.skipped, undefined); // a real failure — the adapter must log it
-  assert.equal(r.error.code, "FORBIDDEN_SCOPE");
-});
-
-test("emitTyping: a dead transport fails open too", async () => {
-  const f = async () => {
-    throw new Error("ECONNREFUSED");
-  };
-  const r = await emitTyping({ channelId: "ch_1", cfg: CFG, fetchImpl: f });
-  assert.equal(r.ok, false);
-  assert.ok(r.error);
-});
-
-// --- the adapter ------------------------------------------------------------
-
-/** Adapter under test with injected emit + timers. */
-function makeAdapter(emitImpl, over = {}) {
-  const calls = [];
-  const logs = [];
-  const timers = fakeTimers();
-  const emit = async (o) => {
-    calls.push(o);
-    return emitImpl ? emitImpl(o, calls.length - 1) : { ok: true, refreshAfterMs: 3000 };
-  };
-  const adapter = createCohortTypingAdapter({
-    emit,
-    log: (m) => logs.push(m),
-    setInterval: timers.setInterval,
-    clearInterval: timers.clearInterval,
-    ...over,
-  });
-  return { adapter, calls, logs, timers };
-}
-
-const SOURCE = { channel: "cohort", chatId: "ch_1", threadRef: undefined, userScope: "channel" };
-
-test("startTypingHeartbeat: beats immediately, then on the interval", async () => {
-  const { adapter, calls, timers } = makeAdapter();
-  const key = adapter.startTypingHeartbeat(SOURCE);
-  await new Promise((r) => setImmediate(r));
-
-  assert.equal(key, "ch_1");
-  assert.equal(calls.length, 1, "the indicator must show without waiting a full tick");
-  assert.deepEqual({ channelId: calls[0].channelId, state: calls[0].state }, { channelId: "ch_1", state: true });
-
-  await timers.tick();
-  assert.equal(calls.length, 2);
-  assert.equal(calls[1].state, true);
-});
-
-test("start is idempotent per conversation; thread and channel are distinct keys", async () => {
-  const { adapter, timers } = makeAdapter();
-  adapter.startTypingHeartbeat(SOURCE);
-  adapter.startTypingHeartbeat(SOURCE);
-  assert.deepEqual(adapter.activeKeys(), ["ch_1"]);
-  assert.equal(timers.timers.size, 1);
-
-  adapter.startTypingHeartbeat({ chatId: "ch_1", threadRef: "msg_root" });
-  assert.deepEqual(adapter.activeKeys(), ["ch_1", "ch_1|msg_root"]);
-});
-
-test("stopTypingHeartbeat: clears the timer AND publishes state:false", async () => {
-  const { adapter, calls, timers } = makeAdapter();
-  adapter.startTypingHeartbeat(SOURCE);
-  await new Promise((r) => setImmediate(r));
-  adapter.stopTypingHeartbeat(SOURCE);
-  await new Promise((r) => setImmediate(r));
-
-  assert.equal(timers.timers.size, 0);
-  assert.deepEqual(adapter.activeKeys(), []);
-  assert.equal(calls[calls.length - 1].state, false, "composing must not outlive the reply");
-});
-
-test("stopTypingHeartbeat by KEY still clears the indicator (dispatcher close path)", async () => {
-  const { adapter, calls } = makeAdapter();
-  const key = adapter.startTypingHeartbeat(SOURCE);
-  await new Promise((r) => setImmediate(r));
-  adapter.stopTypingHeartbeat(key);
-  await new Promise((r) => setImmediate(r));
-  assert.equal(calls[calls.length - 1].state, false);
-});
-
-test("stop is idempotent and a stop for an unknown key is a no-op", async () => {
-  const { adapter } = makeAdapter();
-  adapter.stopTypingHeartbeat("never-started");
-  adapter.stopTypingHeartbeat(SOURCE);
-  assert.deepEqual(adapter.activeKeys(), []);
-});
-
-test("a source with no channel id never starts a heartbeat", () => {
-  const { adapter, timers } = makeAdapter();
-  assert.equal(adapter.startTypingHeartbeat({ chatId: "" }), "");
-  assert.equal(adapter.startTypingHeartbeat(null), "");
-  assert.equal(timers.timers.size, 0);
-});
-
-test("the cadence is the SERVER's answer, clamped to sane bounds", async () => {
-  const a = makeAdapter(() => ({ ok: true, refreshAfterMs: 4500 }));
-  a.adapter.startTypingHeartbeat(SOURCE);
-  await new Promise((r) => setImmediate(r));
-  assert.equal(a.adapter.intervalMs, 4500);
-
-  const hot = makeAdapter(() => ({ ok: true, refreshAfterMs: 1 }));
-  hot.adapter.startTypingHeartbeat(SOURCE);
-  await new Promise((r) => setImmediate(r));
-  assert.equal(hot.adapter.intervalMs, MIN_INTERVAL_MS, "a bad value must not become a hot loop");
-
-  const slow = makeAdapter(() => ({ ok: true, refreshAfterMs: 10 * 60_000 }));
-  slow.adapter.startTypingHeartbeat(SOURCE);
-  await new Promise((r) => setImmediate(r));
-  assert.equal(slow.adapter.intervalMs, MAX_INTERVAL_MS, "a slow value must not blink the indicator");
-
-  const none = makeAdapter(() => ({ ok: true }));
-  none.adapter.startTypingHeartbeat(SOURCE);
-  await new Promise((r) => setImmediate(r));
-  assert.equal(none.adapter.intervalMs, DEFAULT_INTERVAL_MS);
-});
-
-test("a failing server logs ONCE per throttle window, never once per beat", async () => {
-  let now = 0;
-  const { adapter, logs, timers } = makeAdapter(
-    () => ({ ok: false, error: { code: "INTERNAL", message: "boom" } }),
-    { now: () => now }
-  );
-  adapter.startTypingHeartbeat(SOURCE);
-  await new Promise((r) => setImmediate(r));
-  for (let i = 0; i < 20; i++) {
-    now += 1_000;
-    await timers.tick();
-  }
-  assert.equal(logs.length, 1, "20 failed beats over 20s must not be 20 log lines");
-  assert.match(logs[0], /typing start failed for ch_1: INTERNAL boom/);
-
-  now += LOG_THROTTLE_MS;
-  await timers.tick();
-  assert.equal(logs.length, 2, "but a still-broken indicator must resurface each window");
-});
-
-test("a skipped (un-enrolled) beat is never logged — configuration is not failure", async () => {
-  const { adapter, logs, timers } = makeAdapter(() => ({ ok: false, skipped: true }));
-  adapter.startTypingHeartbeat(SOURCE);
-  await new Promise((r) => setImmediate(r));
-  await timers.tick();
-  assert.deepEqual(logs, []);
-});
-
-test("a throwing emit can never reach the session path", async () => {
-  const { adapter, logs } = makeAdapter(() => {
-    throw new Error("kaboom");
-  });
-  assert.doesNotThrow(() => adapter.startTypingHeartbeat(SOURCE));
-  await new Promise((r) => setImmediate(r));
-  assert.equal(logs.length, 1);
-  assert.match(logs[0], /threw/);
-});
-
-test("stopAll clears every heartbeat (daemon shutdown)", async () => {
-  const { adapter, timers } = makeAdapter();
-  adapter.startTypingHeartbeat({ chatId: "ch_1" });
-  adapter.startTypingHeartbeat({ chatId: "ch_2" });
-  adapter.stopAll();
-  assert.deepEqual(adapter.activeKeys(), []);
-  assert.equal(timers.timers.size, 0);
-});
-
-test("cohortTypingAdapter is a process singleton (one seat, one adapter)", () => {
-  resetCohortTypingAdapter();
-  const a = cohortTypingAdapter();
-  assert.equal(cohortTypingAdapter(), a);
-  resetCohortTypingAdapter();
-  assert.notEqual(cohortTypingAdapter(), a);
-  resetCohortTypingAdapter();
-  resetTypingConfigCache();
-});