@cohortapp/agent-sdk 2.3.1 → 2.4.0

package/lib/org/mesh.mjs

@@ -331,6 +331,34 @@ async function beatOnce(ctx) {
     logWarn(`presence beat failed (${err && err.message}) — org may be down, continuing standalone`);
     return [];
   }
+
+  // A REJECTED beat is not a thrown beat. `presenceBeat` RESOLVES with a res
+  // FRAME — {ok:false,error:{code,message}} — for 401/403/404/500 alike, so the
+  // catch above only ever sees transport failures. Without this, a beat the
+  // server refuses is indistinguishable from one it accepted: nothing is logged,
+  // extractDirectives yields [], and the agent looks perfectly healthy while it
+  // is not in the mesh at all. Observed in the wild: an empty token produced a
+  // silent 401 on every beat for the life of the process.
+  //
+  // WARN ONLY — do NOT return early. An error frame is also how the kill switch
+  // arrives for a DEACTIVATED token: the server refuses the beat and rides
+  // `directive: "halt"` on the error. Returning here would drop exactly the
+  // signal that must never be dropped, so the directive walk below still runs.
+  //
+  // Logged, not thrown: the loop stays fail-open by design (the org being down
+  // must never take the daemon down). Being LOUD is the fix, not dying.
+  if (frame && frame.ok === false) {
+    const code = (frame.error && frame.error.code) || "UNKNOWN";
+    const msg = (frame.error && frame.error.message) || "";
+    logWarn(
+      `presence beat REJECTED by the org (${code}${msg ? `: ${msg}` : ""}) — ` +
+      `this agent is NOT in the mesh and will not receive directives` +
+      (code === "UNAUTHORIZED"
+        ? `. Check COHORT_API_KEY in .env is present and paired`
+        : ""),
+    );
+  }
+
   const directives = extractDirectives(frame);
   for (const d of directives) {
     try { await handleDirective(d, ctx); } catch { /* each directive is independently fail-open */ }
@@ -421,13 +449,28 @@ export async function connectOrgMesh(o = {}) {
     if (entry && entry.id) {
       // Fetch THIS seat's granted tools (SP5); falls back to workspace-wide when absent.
       ctx.agentMemberId = entry.id;
-      await client.register(entry, {
+      // The rich self-entry is projected onto hq's `.strict()` registerSchema by
+      // the wire contract inside client.call (param-contract#toRegisterParams);
+      // passing it raw used to 400 on every boot.
+      const frame = await client.register(entry, {
         base: conn.base,
         token: conn.token,
         idempotencyKey: `registry.register:${entry.id}`,
         fetchImpl: o.fetchImpl,
       });
-      logInfo(`registered ${entry.id} with the org mesh`);
+      // NEVER claim success we did not get. `register` fails OPEN (it returns an
+      // error frame rather than throwing), and this line used to log "registered
+      // …" unconditionally — so a rejected registration looked healthy on every
+      // boot while the agent was absent from the directory.
+      if (frame && frame.ok) {
+        logInfo(`registered ${entry.id} with the org mesh`);
+      } else {
+        const err = (frame && frame.error) || {};
+        logWarn(
+          `registration REJECTED for ${entry.id} (${err.code || "unknown"}: ${err.message || "no detail"}) ` +
+            `— this agent is NOT in the org directory; presence-beat will retry`,
+        );
+      }
     }
   } catch (err) {
     logWarn(`registration failed (${err && err.message}) — continuing; presence-beat will retry`);

package/lib/org/mesh.test.mjs

@@ -216,6 +216,61 @@ test("org unreachable: presence beat that rejects never throws (fail-open)", asy
   handle.stop();
 });
 
+test("a REJECTED beat (error frame, not a throw) is loudly warned, not silently ignored", async () => {
+  const root = tmpRepo();
+  // A refused beat resolves with an error FRAME — it does not throw — so the
+  // fail-open catch above never sees it. Before this was handled, an agent with
+  // a bad/empty token 401'd on every beat for the life of the process while
+  // logging nothing: it was not in the mesh, could not receive `halt`, and
+  // looked perfectly healthy.
+  const client = fakeClient({
+    beatFrames: [{ ok: false, error: { code: "UNAUTHORIZED", message: "bad key" } }],
+  });
+
+  const warnings = [];
+  const realWarn = console.warn;
+  console.warn = (...a) => { warnings.push(a.join(" ")); };
+  let directives;
+  try {
+    const handle = await connectOrgMesh({
+      agentRoot: root, cfg: cfgEnabled(), client,
+      setInterval: () => ({ unref() {} }),
+    });
+    directives = await _internals.beatOnce(handle._ctx);
+    handle.stop();
+  } finally {
+    console.warn = realWarn;
+  }
+
+  assert.deepEqual(directives, [], "a rejected beat yields no directives");
+  const warned = warnings.join("\n");
+  assert.match(warned, /REJECTED/, "the rejection must be logged, not swallowed");
+  assert.match(warned, /UNAUTHORIZED/, "the error code must reach the operator");
+  assert.match(warned, /COHORT_API_KEY/, "an auth failure must name the likely cause");
+});
+
+test("an accepted beat logs no rejection warning", async () => {
+  const root = tmpRepo();
+  const client = fakeClient({ beatFrames: [{ ok: true, result: { directives: [] } }] });
+  const warnings = [];
+  const realWarn = console.warn;
+  console.warn = (...a) => { warnings.push(a.join(" ")); };
+  try {
+    const handle = await connectOrgMesh({
+      agentRoot: root, cfg: cfgEnabled(), client,
+      setInterval: () => ({ unref() {} }),
+    });
+    await _internals.beatOnce(handle._ctx);
+    handle.stop();
+  } finally {
+    console.warn = realWarn;
+  }
+  assert.ok(
+    !warnings.join("\n").includes("REJECTED"),
+    "a healthy beat must not cry wolf",
+  );
+});
+
 test("registration failure at boot is swallowed; the mesh still comes up", async () => {
   const root = tmpRepo();
   const client = fakeClient();

package/lib/org/messaging.mjs

@@ -195,12 +195,19 @@ export async function sendMessage(params = {}, o = {}) {
 
   // (3) the wire — idempotent on the client message id.
   const idempotencyId = params.idempotencyId != null ? String(params.idempotencyId) : "";
+  // WIRE NAMES MUST MATCH hq's zod schema (server/validation/message.sendMessageBase):
+  //   channelId, body, threadRootId, idempotencyId
+  // This sent `channel`, `threadId` and `id`, so EVERY messaging.send from the
+  // SDK was rejected with "channelId: Required" — no agent could post to Cohort
+  // at all. The legacy names are kept alongside for any older server that still
+  // reads them; the canonical ones are what hq validates.
   const wire = {
+    channelId: channel,
     channel,
     body: text,
     ...(Array.isArray(params.mentions) && params.mentions.length ? { mentions: params.mentions.map(String) } : {}),
-    ...(params.threadId != null ? { threadId: String(params.threadId) } : {}),
-    ...(idempotencyId ? { id: idempotencyId } : {}),
+    ...(params.threadId != null ? { threadRootId: String(params.threadId), threadId: String(params.threadId) } : {}),
+    ...(idempotencyId ? { idempotencyId, id: idempotencyId } : {}),
   };
   const frame = await call("messaging.send", wire, {
     base: org.base,
@@ -237,7 +244,7 @@ export async function reactMessage(params = {}, o = {}) {
   const org = resolveOrg(o.cfg);
   if (!org) return errFrame("BAD_REQUEST", "org messaging disabled or unconfigured");
 
-  const frame = await call("messaging.react", { channel, messageId, emoji }, {
+  const frame = await call("messaging.react", { channelId: channel, channel, messageId, emoji }, {
     base: org.base,
     token: org.token,
     idempotencyKey: o.idempotencyKey,
@@ -265,6 +272,11 @@ export async function fetchHistory(params = {}, o = {}) {
   const frame = await call(
     "messaging.history",
     {
+      // hq's handler validates `channelId` (zod). The SDK sent `channel`, so
+      // messaging.history returned BAD_REQUEST on every call and no caller ever
+      // received history. Send both: `channelId` is what the server reads, and
+      // `channel` is kept for any older server still accepting the legacy name.
+      channelId: channel,
       channel,
       ...(params.since != null ? { since: params.since } : {}),
       ...(params.cursor != null ? { cursor: params.cursor } : {}),
@@ -372,10 +384,17 @@ export async function joinCall(params = {}, o = {}) {
  * here as `nextCursor`) so a crash never loses or double-delivers events.
  *
  * Mention detection: an event whose `mentions[]` (or `mentioned_agents[]`)
- * includes this agent's id, OR a DM-kind event addressed to it, counts as
- * directed. We do NOT include the agent's own outbound echoes (`from` == self).
+ * includes this agent's id, OR a message in a PRIVATE ROOM this agent belongs
+ * to (DM / group DM / huddle), counts as directed. We do NOT include the
+ * agent's own outbound echoes (`from` == self).
+ *
+ * The org event feed is org-wide and redacted, so room membership has to come
+ * from the agent itself — we resolve it once per pull via `messaging.channels`
+ * (see {@link isDirectedAtAgent} for why this is load-bearing rather than an
+ * optimisation). Fail-open: if the roster cannot be read we simply pass
+ * `undefined`, and the filter stays conservative rather than guessing.
  *
- * @param {object} o - { cfg, agentId?, cursor?, limit?, fetchImpl? }
+ * @param {object} o - { cfg, agentId?, cursor?, limit?, fetchImpl?, myChannelIds? }
  * @returns {Promise<{events:object[], nextCursor:(number|string|null)}>}
  */
 export async function pullInbound(o = {}) {
@@ -389,6 +408,21 @@ export async function pullInbound(o = {}) {
   const r = await read(path, { base: org.base, token: org.token, fetchImpl: o.fetchImpl });
   if (!r.ok || !r.payload) return { events: [], nextCursor: cursor };
 
+  // Which rooms am I in? Injectable for tests; otherwise one cheap RPC per pull.
+  let myChannelIds = o.myChannelIds;
+  if (myChannelIds == null) {
+    try {
+      const channels = await listChannels({ cfg: o.cfg, fetchImpl: o.fetchImpl });
+      if (Array.isArray(channels)) {
+        myChannelIds = new Set(
+          channels.map((c) => String((c && (c.id || c.channelId)) || "")).filter(Boolean),
+        );
+      }
+    } catch {
+      myChannelIds = undefined; // unknown → conservative filter, never a throw
+    }
+  }
+
   const raw = Array.isArray(r.payload) ? r.payload : (Array.isArray(r.payload.events) ? r.payload.events : []);
   let maxSeq = cursor;
   const events = [];
@@ -396,20 +430,126 @@ export async function pullInbound(o = {}) {
     if (ev && (ev.seq != null) && Number.isFinite(Number(ev.seq))) {
       maxSeq = Math.max(Number(maxSeq) || 0, Number(ev.seq));
     }
-    const directed = isDirectedAtAgent(ev, me);
-    if (!directed) continue;
-    events.push(toMessageEvent(ev, me));
+    const directed = isDirectedAtAgent(ev, me, { myChannelIds });
+    if (directed) {
+      events.push(toMessageEvent(ev, me));
+      continue;
+    }
+    // MENTION CANDIDATE. The org-wide feed says `mentionCount` — a NUMBER —
+    // and deliberately does NOT name who was mentioned: it is readable by every
+    // agent holding `org.read`, so listing member ids there would leak the
+    // association graph of private rooms (the payload is a REDACTED audit row
+    // by design). That redaction is right, and it is also why this filter alone
+    // is deaf to an @mention in a space.
+    //
+    // So resolve it the ACL-safe way: mark it a candidate here and confirm it
+    // below against `messaging.history`, which hq gates PER MEMBER. If this
+    // agent cannot read that room, it gets nothing back and the candidate is
+    // dropped — fail-closed, with no widening of what the shared feed says.
+    const p = ev.payload || ev;
+    const count = Number(p.mentionCount || 0);
+    if (me && count > 0) {
+      const cand = toMessageEvent(ev, me);
+      cand._mentionCandidate = true;
+      events.push(cand);
+    }
+  }
+
+  // HYDRATE THE BODY. The org event feed is redacted by design — it carries
+  // {actor, channelId, channelKind, counts, ts} and NO message text — so a
+  // projected event arrives with `text: ""`. An empty inbound is worse than no
+  // inbound: the classifier sees nothing to classify and the agent would
+  // "reply" to a blank message.
+  //
+  // The body is fetched over `messaging.history`, which is ACL'd server-side to
+  // rooms this agent belongs to — so hydration cannot widen what the agent can
+  // see, it only re-joins content the agent was always entitled to read. One
+  // fetch per affected channel, not per message.
+  //
+  // Fail-open: a message we cannot hydrate is dropped rather than delivered
+  // blank, because a blank inbound produces a nonsense reply in a real room.
+  const needBody = events.filter((e) => (!e.text || e._mentionCandidate) && e.kind !== "call");
+  if (needBody.length) {
+    const byChannel = new Map();
+    for (const e of needBody) {
+      if (!e.channel_id) continue;
+      if (!byChannel.has(e.channel_id)) byChannel.set(e.channel_id, []);
+      byChannel.get(e.channel_id).push(e);
+    }
+    for (const [channelId, pending] of byChannel) {
+      try {
+        const history = await fetchHistory(
+          { channel: channelId, limit: 50 },
+          { cfg: o.cfg, fetchImpl: o.fetchImpl },
+        );
+        const byId = new Map(
+          (Array.isArray(history) ? history : [])
+            .map((m) => [String((m && (m.id || m.messageId)) || ""), m])
+            .filter(([id]) => id),
+        );
+        for (const e of pending) {
+          const hit = byId.get(String(e.message_id));
+          if (!hit) continue;
+          e.text = String(hit.body ?? hit.text ?? "");
+          // The ACL'd read is the ONLY place mention identities are trusted.
+          e._mentions = Array.isArray(hit.mentions)
+            ? hit.mentions.map((m) => String((m && (m.memberId || m.id)) ?? m))
+            : [];
+          if (!e.from.name || e.from.name === e.from.id) {
+            e.from.name = String(hit.authorName || hit.author?.displayName || e.from.name || "");
+          }
+        }
+      } catch {
+        /* fail-open: leave these unhydrated; they are dropped just below */
+      }
+    }
   }
-  return { events, nextCursor: raw.length ? maxSeq : cursor };
+
+  // Confirm the mention candidates against what history actually returned. A
+  // candidate survives ONLY if this agent's id is in that message's `mentions`
+  // — proven by an ACL'd read, never inferred from the shared feed.
+  const confirmed = events.filter((e) => {
+    if (!e._mentionCandidate) return true;
+    const ok = Array.isArray(e._mentions) && e._mentions.map(String).includes(String(me));
+    if (!ok) return false;
+    e.reason = "mention";
+    return true;
+  });
+  for (const e of confirmed) { delete e._mentionCandidate; delete e._mentions; }
+
+  const delivered = confirmed.filter((e) => e.kind === "call" || (e.text && e.text.trim()));
+  return { events: delivered, nextCursor: raw.length ? maxSeq : cursor };
 }
 
 /**
  * Decide whether an org event is directed at this agent (an inbound it should
  * react to) vs ambient chatter / its own echo. Pure.
- * @param {object} ev @param {string} me agent id
+ *
+ * WHY THIS NEEDS `myChannelIds`. The `/v1/events` feed is ORG-scoped, not
+ * member-scoped — an agent sees every messaging event in the org — and the
+ * payload is deliberately REDACTED: hq emits only
+ *   { actor, channelId, channelKind, recipientCount, mentionCount, ts }
+ * with no body and, crucially, NO recipient list. That redaction is correct
+ * (an org-wide feed must not leak who DMs whom), but it means "is this for me?"
+ * cannot be answered from the event alone. The agent's OWN channel membership
+ * is the missing half, and the agent already knows it (`messaging.channels`).
+ *
+ * This bit in production: a human DM'd an agent six times and the agent never
+ * saw a single message. The old code looked for a `to` array the payload never
+ * carries, then fell back to `p.kind` containing "dm" — but the event's kind is
+ * "send" and the DM-ness lives in `channelKind: "DM"`, which nothing inspected.
+ * Every human DM was silently dropped.
+ *
+ * Without `myChannelIds` this stays CONSERVATIVE for DMs (returns false rather
+ * than guessing), because the failure mode of guessing yes is an agent barging
+ * into other people's private conversations.
+ *
+ * @param {object} ev
+ * @param {string} me agent id
+ * @param {{myChannelIds?: Set<string>|string[]}} [opts]
  * @returns {boolean}
  */
-export function isDirectedAtAgent(ev, me) {
+export function isDirectedAtAgent(ev, me, opts = {}) {
   if (!ev || typeof ev !== "object") return false;
   const family = ev.family || (ev.kind ? String(ev.kind).split(".")[0] : "");
   if (family && family !== "messaging" && family !== "calling") return false;
@@ -423,21 +563,46 @@ export function isDirectedAtAgent(ev, me) {
     .map((m) => String(m));
   if (me && mentions.includes(String(me))) return true;
 
-  // A DM / direct call-invite addressed to this agent is directed even with no
-  // explicit @mention.
+  // An explicit recipient list, when a producer supplies one.
   const to = []
     .concat(Array.isArray(p.to) ? p.to : (p.to != null ? [p.to] : []))
     .concat(Array.isArray(p.invitees) ? p.invitees : [])
     .map((t) => String(t));
   if (me && to.includes(String(me))) return true;
 
+  // The REAL hq shape: a private room I am a member of. Membership is what makes
+  // it mine — in a DM/group-DM/huddle every message is addressed to the room,
+  // so no @mention is required.
+  const mine = normaliseChannelIds(opts.myChannelIds);
+  const channelId = String(p.channelId || p.channel || p.callId || "");
+  const channelKind = String(p.channelKind || p.channel_kind || "").toUpperCase();
+  const PRIVATE_ROOMS = ["DM", "GROUP_DM", "HUDDLE"];
+  if (mine && channelId && mine.has(channelId)) {
+    if (PRIVATE_ROOMS.includes(channelKind)) return true;
+    // A call event in one of my rooms is an invite I should react to.
+    if (family === "calling") return true;
+  }
+
+  // Legacy/other producers that put the room kind in `kind` rather than
+  // `channelKind`. Unchanged behaviour for them.
   const kind = String(p.kind || ev.kind || "").toLowerCase();
-  if (kind.includes("dm") || kind.includes("invite") || family === "calling") {
+  if (kind.includes("dm") || kind.includes("invite")) {
+    return !me || to.includes(String(me)) || mentions.includes(String(me)) || to.length === 0;
+  }
+  // A bare `calling` event with no room context: only when we cannot scope it.
+  if (family === "calling" && !mine) {
     return !me || to.includes(String(me)) || mentions.includes(String(me)) || to.length === 0;
   }
   return false;
 }
 
+/** Accept a Set, an array, or nothing; null means "membership unknown". */
+function normaliseChannelIds(v) {
+  if (v instanceof Set) return v;
+  if (Array.isArray(v)) return new Set(v.map((x) => String(x)));
+  return null;
+}
+
 /**
  * Project an org messaging/calling event onto the unified MessageEvent contract
  * (lib/channels/contract.MessageEvent) so eventToInboxItem can serialise it into

package/lib/org/messaging.test.mjs

@@ -236,3 +236,120 @@ test("pullInbound: org disabled → empty, cursor preserved (fail-open)", async
   assert.deepEqual(events, []);
   assert.equal(nextCursor, 5);
 });
+
+// ---------------------------------------------------------------------------
+// The REAL hq event shape — regression for the silent-DM-drop
+// ---------------------------------------------------------------------------
+
+/** Exactly what hq appends for a human DM (redacted: no body, no recipients). */
+function hqDmEvent(overrides = {}) {
+  return {
+    seq: 9880,
+    family: "messaging",
+    kind: "send",
+    entityId: "cmsnbhmqy004blj016kot2pwi",
+    actor: "human-1",
+    at: "2026-08-10T14:18:55.978Z",
+    payload: {
+      ts: "2026-08-10T14:18:55.978Z",
+      actor: "human-1",
+      threaded: false,
+      channelId: "dm-human-agent",
+      channelKind: "DM",
+      mentionCount: 0,
+      recipientCount: 2,
+      attachmentCount: 0,
+      ...overrides,
+    },
+  };
+}
+
+test("isDirectedAtAgent: a human DM in MY room is directed (the production silent-drop)", () => {
+  // Six real DMs were dropped: the filter wanted a `to` list the redacted
+  // payload never carries, and checked `kind` for "dm" when the kind is "send"
+  // and the room type lives in `channelKind`.
+  const mine = new Set(["dm-human-agent"]);
+  assert.equal(isDirectedAtAgent(hqDmEvent(), "agent-self", { myChannelIds: mine }), true);
+});
+
+test("isDirectedAtAgent: a DM I am NOT in is NOT mine (org feed is org-wide)", () => {
+  // /v1/events is org-scoped, so an agent sees other people's DM events too.
+  // Reacting to those would be barging into private conversations.
+  const mine = new Set(["dm-human-agent"]);
+  const someoneElses = hqDmEvent({ channelId: "dm-human-other" });
+  assert.equal(isDirectedAtAgent(someoneElses, "agent-self", { myChannelIds: mine }), false);
+});
+
+test("isDirectedAtAgent: without membership context it stays CONSERVATIVE on DMs", () => {
+  // Guessing "yes" without knowing the roster is the dangerous direction.
+  assert.equal(isDirectedAtAgent(hqDmEvent(), "agent-self"), false);
+});
+
+test("isDirectedAtAgent: my own echo in my own DM is still ignored", () => {
+  const mine = new Set(["dm-human-agent"]);
+  const echo = hqDmEvent({ actor: "agent-self" });
+  echo.actor = "agent-self";
+  assert.equal(isDirectedAtAgent(echo, "agent-self", { myChannelIds: mine }), false);
+});
+
+test("isDirectedAtAgent: a PUBLIC channel message in my room is NOT directed on its own", () => {
+  // Membership in a public channel is not an invitation to answer everything;
+  // that needs an @mention (which the redacted payload cannot yet express —
+  // hq emits mentionCount, not the ids).
+  const mine = new Set(["general"]);
+  const pub = hqDmEvent({ channelId: "general", channelKind: "PUBLIC" });
+  assert.equal(isDirectedAtAgent(pub, "agent-self", { myChannelIds: mine }), false);
+});
+
+test("isDirectedAtAgent: an explicit mentions[] still wins anywhere", () => {
+  const mine = new Set(["general"]);
+  const pub = hqDmEvent({ channelId: "general", channelKind: "PUBLIC", mentions: ["agent-self"] });
+  assert.equal(isDirectedAtAgent(pub, "agent-self", { myChannelIds: mine }), true);
+});
+
+test("isDirectedAtAgent: a call event in my room is an invite", () => {
+  const mine = new Set(["room-1"]);
+  const ev = { family: "calling", kind: "start", actor: "human-1",
+               payload: { channelId: "room-1", topic: "standup" } };
+  assert.equal(isDirectedAtAgent(ev, "agent-self", { myChannelIds: mine }), true);
+});
+
+test("isDirectedAtAgent: the SHARED feed never names who was mentioned", () => {
+  // hq's chain payload is a REDACTED audit row read by every agent holding
+  // `org.read`, so it carries `mentionCount` and deliberately NOT the member
+  // ids — listing them would leak the association graph of private rooms. This
+  // filter therefore cannot resolve a space @mention on its own, BY DESIGN;
+  // pullInbound confirms candidates against the per-member `messaging.history`
+  // read instead. Asserted so nobody "fixes" the deafness by widening the feed.
+  const shared = {
+    family: "messaging", kind: "send", entityId: "msg_1", actor: "human-1",
+    payload: { channelId: "space-general", channelKind: "PUBLIC", mentionCount: 1 },
+  };
+  assert.equal(isDirectedAtAgent(shared, "agent-self"), false);
+});
+
+test("isDirectedAtAgent: an explicit mentions[] still wins when a producer supplies one", () => {
+  // hq's chain payload used to carry `mentionCount` — a NUMBER — so an agent
+  // tailing the feed could see that a mention happened but not that it was the
+  // one mentioned. Combined with hq deferring to live daemons, an @mention in a
+  // public space reached nobody: the server stayed quiet and the agent was deaf.
+  // hq now emits `mentions: [memberId…]`, which this filter already understood.
+  const ev = {
+    seq: 10500,
+    family: "messaging",
+    kind: "send",
+    entityId: "msg_1",
+    actor: "human-1",
+    payload: {
+      channelId: "space-general",
+      channelKind: "PUBLIC",
+      mentions: ["agent-self"],
+      mentionCount: 1,
+      recipientCount: 12,
+    },
+  };
+  // Membership is NOT required for a mention — being named is the invitation.
+  assert.equal(isDirectedAtAgent(ev, "agent-self"), true);
+  // …and someone else's mention in the same space is still not ours.
+  assert.equal(isDirectedAtAgent(ev, "agent-other"), false);
+});