agent-relay-server 0.31.0 → 0.31.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-relay-server",
-  "version": "0.31.0",
+  "version": "0.31.1",
   "description": "Lightweight HTTP message relay for inter-agent communication across machines",
   "module": "src/index.ts",
   "type": "module",

package/src/agent-ref.ts

@@ -105,6 +105,24 @@ export function matchAgents(ref: string, agents: AgentCard[], opts: ResolveOptio
   return pool.filter((a) => idMatchesSegment(a.id, trimmed));
 }
 
+/** A channel/bridge agent (Telegram, Slack, …) — the canonical endpoint for its provider name. */
+export function isChannelAgent(agent: AgentCard): boolean {
+  return agent.kind === "channel" || (agent.meta?.kind as unknown) === "channel";
+}
+
+/**
+ * A channel agent is the canonical OWNER of its provider/account name, so a bare ref that
+ * names a channel ("telegram") must resolve to that channel even when provider agents in the
+ * channel's pool carry the same string as a label/tag. Without this, the bare channel name
+ * collides with its own pool and resolves to an arbitrary live pool member — worst case the
+ * sender itself — so the bridge never receives the message and it never reaches the chat
+ * (#290). Returns the single channel in `candidates`, or null if there isn't exactly one.
+ */
+function soleChannel(candidates: AgentCard[]): AgentCard | null {
+  const channels = candidates.filter(isChannelAgent);
+  return channels.length === 1 ? channels[0]! : null;
+}
+
 /**
  * Resolve `ref` to a SINGLE agent. Prefers online matches; reports ambiguity rather
  * than guessing. On not_found, returns any offline matches so callers can say "exists
@@ -116,8 +134,15 @@ export function resolveAgentRef(ref: string, agents: AgentCard[], opts: ResolveO
   if (matches.length === 0) return { status: "not_found", offlineMatches: [] };
 
   const online = matches.filter((a) => isAgentOnline(a, now));
+  // Channel precedence: when a bare ref matches a channel, the channel wins over provider
+  // agents that merely share its name — both when live and (so the caller reports "bridge
+  // offline" rather than misrouting to a pool member) when momentarily down.
+  const onlineChannel = soleChannel(online);
+  if (onlineChannel) return { status: "resolved", agent: onlineChannel };
   if (online.length === 1) return { status: "resolved", agent: online[0]! };
   if (online.length > 1) return { status: "ambiguous", candidates: online };
+  const offlineChannel = soleChannel(matches);
+  if (offlineChannel) return { status: "not_found", offlineMatches: [offlineChannel] };
   return { status: "not_found", offlineMatches: matches };
 }
 
@@ -193,7 +218,8 @@ function notFoundMessage(ref: string, agents: AgentCard[]): string {
  * a live recipient exists; fan-out targets report how many online members they reach;
  * reserved/policy targets pass through unchanged.
  */
-export function planSend(to: string, agents: AgentCard[], now: number = Date.now()): SendPlan {
+export function planSend(to: string, agents: AgentCard[], opts: ResolveOptions = {}): SendPlan {
+  const now = opts.now ?? Date.now();
   const target = to.trim();
 
   if (target === "broadcast") {
@@ -209,8 +235,9 @@ export function planSend(to: string, agents: AgentCard[], now: number = Date.now
     return { kind: "passthrough", to: target, receipt: { delivered: true, expectReply: true, recipients: [target] } };
   }
 
-  // Direct single-agent reference.
-  const resolved = resolveAgentRef(target, agents, { now });
+  // Direct single-agent reference. `excludeId` (the sender) keeps a bare ref from ever
+  // resolving back to its own author — a self-loop silently swallows the message (#290).
+  const resolved = resolveAgentRef(target, agents, opts);
   if (resolved.status === "resolved") {
     return { kind: "direct", to: resolved.agent.id, receipt: { delivered: true, expectReply: true, recipients: [resolved.agent.id] } };
   }

package/src/mcp.ts

@@ -564,13 +564,15 @@ function relaySendMessage(auth: McpAuthContext, args: Record<string, unknown>):
   const attachments = optionalAttachments(args.attachments);
   const payload = payloadWithAttachments(optionalRecord(args.payload, "payload"), attachments);
   const requestedTo = stringField(args.to, "to", { required: true, max: 200 });
+  const sender = resolveSender(auth, args.from);
   // Resolve the target to a canonical agent id (so poll-time matching works) and refuse
   // up front when it's unknown or ambiguous — never store a message no one will receive.
-  const plan = planSend(requestedTo, listAgents());
+  // Exclude the sender so a bare ref can't loop back to its own author (#290).
+  const plan = planSend(requestedTo, listAgents(), { excludeId: sender });
   if (plan.kind === "not_found") throw new McpNotFoundError(plan.message);
   if (plan.kind === "ambiguous") throw new ValidationError(plan.message);
   const input: SendMessageInput = {
-    from: resolveSender(auth, args.from),
+    from: sender,
     to: plan.to,
     body: stringField(args.body, "body", { required: true, maxBytes: MAX_BODY_BYTES }),
     subject: optionalString(args.subject, "subject", 200),
@@ -617,7 +619,7 @@ function relayReply(auth: McpAuthContext, args: Record<string, unknown>): Messag
   emitMessage(result.message, result.created);
   // Reply routing is fixed to the parent's sender — never reject, but report whether
   // that original sender is still reachable so the agent doesn't wait forever.
-  const plan = planSend(input.to, listAgents());
+  const plan = planSend(input.to, listAgents(), { excludeId: input.from });
   const delivery: DeliveryReceipt = plan.kind === "not_found" || plan.kind === "ambiguous"
     ? { delivered: false, expectReply: false, recipients: [], reason: "original sender no longer reachable" }
     : plan.receipt;

package/src/routes.ts

@@ -5222,7 +5222,9 @@ const postMessage: Handler = async (req) => {
     // from the provider transcript and stored for the dashboard chat; it must persist
     // regardless of target liveness and never be re-delivered into a session.
     if (!isMechanicalMessageKind(input.kind)) {
-      const plan = planSend(input.to, listAgents());
+      // excludeId: a bare ref must never resolve back to its own author — that self-loop
+      // silently swallows the message (the reddit-briefing → telegram bridge break, #290).
+      const plan = planSend(input.to, listAgents(), { excludeId: input.from });
       if (plan.kind === "ambiguous") return error(plan.message, 409);
       if (plan.kind !== "not_found") input.to = plan.to;
       // Long-standing guard: refuse a direct send to a known-offline agent (now also