@animalabs/agent-framework 0.22.5 → 0.22.6

package/dist/src/mcpl/channel-registry.js

@@ -363,6 +363,8 @@ export class ChannelRegistry {
     dmClassified = new Map();
     /** Most recent incoming channel ID — used for speech routing / default publish. */
     defaultPublishChannel = null;
+    /** The server whose accepted message set defaultPublishChannel. */
+    defaultPublishServer = null;
     /** Most recent incoming message metadata, used for buildChannelContext. */
     defaultPublishMessageId = null;
     defaultPublishThreadId = undefined;
@@ -445,7 +447,7 @@ export class ChannelRegistry {
                 descriptor: channel,
                 open: false,
             });
-            this.appendLabelSighting(channel.id, channel.label, extractDmMeta(channel.metadata));
+            this.appendLabelSighting(serverId, channel.id, channel.label, extractDmMeta(channel.metadata));
             registeredIds.push(channel.id);
             results.push({ id: channel.id, accepted: true });
         }
@@ -506,7 +508,7 @@ export class ChannelRegistry {
                     continue;
                 }
                 existing.descriptor = channel;
-                this.appendLabelSighting(channel.id, channel.label, extractDmMeta(channel.metadata));
+                this.appendLabelSighting(serverId, channel.id, channel.label, extractDmMeta(channel.metadata));
                 addedResults.push({ id: channel.id, accepted: true });
             }
         }
@@ -526,7 +528,7 @@ export class ChannelRegistry {
                     descriptor: channel,
                     open: false,
                 });
-                this.appendLabelSighting(channel.id, channel.label, extractDmMeta(channel.metadata));
+                this.appendLabelSighting(serverId, channel.id, channel.label, extractDmMeta(channel.metadata));
                 addedResults.push({ id: channel.id, accepted: true });
                 accepted.push(channel);
             }
@@ -708,6 +710,7 @@ export class ChannelRegistry {
             // for those this runs after the hook (below).
             const markAccepted = () => {
                 this.defaultPublishChannel = message.channelId;
+                this.defaultPublishServer = serverId;
                 this.defaultPublishMessageId = message.messageId;
                 this.defaultPublishThreadId = message.threadId;
                 // A server sending channels/incoming is authoritative evidence that
@@ -819,7 +822,9 @@ export class ChannelRegistry {
      * richer one.
      */
     ensureChannelRegistered(serverId, channelId, label, extraMetadata) {
-        const existing = this.findChannelEntry(channelId);
+        // The pushing server's own entry: another server's entry for the same id
+        // is that server's, and a push leaves it as it was.
+        const existing = this.channels.get(`${serverId}:${channelId}`);
         if (existing) {
             // Backfill identity onto a bare lazy registration: a DM that first
             // arrived with no label/recipient info gets a usable name the next
@@ -833,7 +838,7 @@ export class ChannelRegistry {
                 // Recorded before the live descriptor takes it, since this branch's
                 // guard reads the descriptor: an append that throws leaves the
                 // placeholder, so the next push tries again.
-                this.appendLabelSighting(existing.descriptor.id, label, extractDmMeta(metadata));
+                this.appendLabelSighting(serverId, existing.descriptor.id, label, extractDmMeta(metadata));
                 existing.descriptor.label = label;
                 existing.descriptor.metadata = metadata;
             }
@@ -853,7 +858,7 @@ export class ChannelRegistry {
         // label to record. A real label is recorded before the entry exists:
         // an append that throws registers nothing, so the next push tries again.
         if (label)
-            this.appendLabelSighting(channelId, label, extractDmMeta(extraMetadata));
+            this.appendLabelSighting(serverId, channelId, label, extractDmMeta(extraMetadata));
         const key = `${serverId}:${channelId}`;
         this.channels.set(key, {
             serverId,
@@ -1044,7 +1049,7 @@ export class ChannelRegistry {
             case 'channel_decline':
                 return this.handleToolDecline(input);
             case 'channel_publish':
-                return this.handleToolPublish(input);
+                return this.handleToolPublish(input, origin);
             case 'think':
                 return this.handleToolThink(input);
             case 'journal':
@@ -1115,8 +1120,11 @@ export class ChannelRegistry {
                 continue;
             this.channels.delete(key);
             this.stopTyping(entry.descriptor.id);
-            if (this.defaultPublishChannel === entry.descriptor.id) {
+            // The fallback goes with the server whose message set it, not with
+            // another server's entry for the same id.
+            if (this.defaultPublishChannel === entry.descriptor.id && this.defaultPublishServer === serverId) {
                 this.defaultPublishChannel = null;
+                this.defaultPublishServer = null;
                 this.defaultPublishMessageId = null;
                 this.defaultPublishThreadId = undefined;
             }
@@ -1136,6 +1144,7 @@ export class ChannelRegistry {
         this.channels.clear();
         // Reset default publish tracking
         this.defaultPublishChannel = null;
+        this.defaultPublishServer = null;
         this.defaultPublishMessageId = null;
         this.defaultPublishThreadId = undefined;
     }
@@ -1269,9 +1278,15 @@ export class ChannelRegistry {
      * `HistoryModule` tool call passes through unguarded via
      * `resolveProseTargetDurable()`.
      */
-    appendLabelSighting(channelId, label, dmMeta = {}) {
+    appendLabelSighting(serverId, channelId, label, dmMeta = {}) {
         if (typeof label !== 'string' || !label)
             return;
+        // The log is kept by the bare id, and a durable lookup by label resolves
+        // to that id with no server. So a server's label for an id another
+        // server registers isn't recorded: it would name the other server's
+        // channel, across restarts.
+        if (this.registeredByAnotherServer(serverId, channelId))
+            return;
         const { recipientId, recipientName, isDm } = dmMeta;
         // Never let a bare-id placeholder (ensureChannelRegistered's fallback
         // `label ?? channelId` when no real label was ever supplied — e.g. a
@@ -1842,10 +1857,26 @@ export class ChannelRegistry {
             .filter((e) => e.serverId === serverId)
             .map((e) => e.descriptor);
     }
+    /**
+     * The server whose accepted message set the global fallback, where
+     * `channelId` is the fallback's channel: a turn whose locus is the
+     * fallback resolves it with this server, taken with the locus.
+     */
+    fallbackServerFor(channelId) {
+        return this.defaultPublishChannel === channelId ? this.defaultPublishServer ?? undefined : undefined;
+    }
     /** Server id owning a registered channel (by descriptor id), or null. */
     getChannelServerId(channelId) {
         return this.findChannelEntry(channelId)?.serverId ?? null;
     }
+    /** Whether a server other than `serverId` registers `channelId`. */
+    registeredByAnotherServer(serverId, channelId) {
+        for (const entry of this.channels.values()) {
+            if (entry.descriptor.id === channelId && entry.serverId !== serverId)
+                return true;
+        }
+        return false;
+    }
     /**
      * Find a channel entry by channelId (searches across all servers).
      * Returns the first match.
@@ -2451,8 +2482,11 @@ export class ChannelRegistry {
      * Fire-and-forget and never throws: streaming is an observer surface; the
      * authoritative delivery is the eventual channels/publish.
      */
-    sendOutgoingChunk(channelId, conversationId, inferenceId, index, delta) {
-        const server = this.streamingServerFor(channelId);
+    sendOutgoingChunk(channelId, conversationId, inferenceId, index, delta, 
+    /** The server the channel resolves with, as the speech's locus does
+     *  (deliverSpeech's locusServerId). */
+    serverId) {
+        const server = this.streamingServerFor(channelId, serverId);
         if (!server)
             return;
         try {
@@ -2461,8 +2495,10 @@ export class ChannelRegistry {
         catch { /* observer surface — never disturb the turn */ }
     }
     /** Spec 14.3 companion: final moderated content per channel at stream end. */
-    sendOutgoingComplete(channelId, conversationId, inferenceId, text) {
-        const server = this.streamingServerFor(channelId);
+    sendOutgoingComplete(channelId, conversationId, inferenceId, text, 
+    /** As sendOutgoingChunk's. */
+    serverId) {
+        const server = this.streamingServerFor(channelId, serverId);
         if (!server)
             return;
         try {
@@ -2475,15 +2511,19 @@ export class ChannelRegistry {
         }
         catch { /* observer surface — never disturb the turn */ }
     }
-    streamingServerFor(channelId) {
+    streamingServerFor(channelId, serverId) {
         // The map is keyed `${serverId}:${channelId}`; stream targets arrive as
-        // bare descriptor ids (what resolveProseTarget returns). Scan like the
-        // resolver does, and fail closed on cross-server ambiguity — the same
-        // never-guess rule that governs delivery.
+        // bare descriptor ids (what resolveProseTarget returns). With the server
+        // the speech resolves with, only that server's entry; otherwise scan like
+        // the resolver does, and fail closed on cross-server ambiguity — the
+        // same never-guess rule that governs delivery.
         const matches = [...this.channels.values()].filter((e) => e.descriptor.id === channelId);
-        if (matches.length !== 1)
+        const entry = serverId !== undefined
+            ? matches.find((e) => e.serverId === serverId)
+            : matches.length === 1 ? matches[0] : undefined;
+        if (!entry)
             return null;
-        const server = this.serverRegistry.getServer(matches[0].serverId);
+        const server = this.serverRegistry.getServer(entry.serverId);
         // §5.4: the GRANT gates streaming, not the raw advertisement. The old
         // `capabilities?.channels?.streaming` check was doubly wrong: undefined
         // for the boolean `channels: true` shape (masking discord-mcpl's latent
@@ -2659,7 +2699,12 @@ export class ChannelRegistry {
     locusChannelId, 
     /** `heldOnFailure`: the caller holds a `failed` delivery's words as a
      *  draft with its own notice, so no failure marker is written for it.
-     *  An `unknown` outcome still gets its marker. */
+     *  An `unknown` outcome still gets its marker. `locusServerId`: the
+     *  server the locus resolves with, snapshotted by the caller with the
+     *  locus: the server whose message triggered the turn, where the locus is
+     *  that message's channel. The speech goes out through that server only,
+     *  and fails where it no longer registers the channel. Without it, the
+     *  locus is taken only where exactly one server registers it. */
     opts) {
         const fail = (channelId, reason, outcome) => {
             const status = outcome.status === 'unknown' ? 'unknown' : 'failed';
@@ -2694,7 +2739,11 @@ export class ChannelRegistry {
             const reason = 'turn has no locus (no home/trigger channel; nothing to deliver into)';
             return fail(null, reason, { status: 'failed', reason, at: Date.now() });
         }
-        const outcome = await this.publish(conversationId, text, { channelId: locusChannelId, routed: true });
+        const outcome = await this.publish(conversationId, text, {
+            ...(opts?.locusServerId !== undefined ? { serverId: opts.locusServerId } : {}),
+            channelId: locusChannelId,
+            routed: true,
+        });
         const channelId = outcome.destination?.channelId ?? locusChannelId;
         if (outcome.status !== 'delivered') {
             return fail(channelId, outcome.reason ?? 'delivery not confirmed', outcome);
@@ -2715,9 +2764,10 @@ export class ChannelRegistry {
         });
         return outcome;
     }
-    /** deliverSpeech, reduced to the confirmed delivery (null when there was none). */
-    async routeSpeech(conversationId, text, locusChannelId) {
-        const outcome = await this.deliverSpeech(conversationId, text, locusChannelId);
+    /** deliverSpeech, reduced to the confirmed delivery (null when there was
+     *  none). `opts.locusServerId` is deliverSpeech's. */
+    async routeSpeech(conversationId, text, locusChannelId, opts) {
+        const outcome = await this.deliverSpeech(conversationId, text, locusChannelId, opts?.locusServerId !== undefined ? { locusServerId: opts.locusServerId } : undefined);
         if (outcome.status !== 'delivered')
             return null;
         return {
@@ -2726,7 +2776,7 @@ export class ChannelRegistry {
             ...(outcome.messageId !== undefined ? { messageId: outcome.messageId } : {}),
         };
     }
-    async handleToolPublish(input) {
+    async handleToolPublish(input, origin) {
         // Resolve content: accept both `content` and `text` (backward compat)
         const messageText = input.content ?? input.text;
         if (!messageText) {
@@ -2745,11 +2795,30 @@ export class ChannelRegistry {
                 isError: true,
             };
         }
-        const entry = this.findChannelEntry(channelId);
+        // A serverId the call gives names the exact pair, as the other channel
+        // tools read theirs (this tool's schema doesn't declare one); with no
+        // channelId, it's the default channel on that server. A call naming no
+        // server takes the calling turn's server for its trigger's or locus's
+        // channel; else, for the default channel, the server whose accepted
+        // message set it; else a channelId only where exactly one server
+        // registers it.
+        const serverId = input.serverId;
+        const trigger = !serverId && origin?.kind === 'agent'
+            ? [origin.trigger, origin.locus].find((o) => o?.channelId === channelId)
+            : undefined;
+        const defaultServer = !serverId && trigger === undefined && input.channelId === undefined
+            ? this.fallbackServerFor(channelId)
+            : undefined;
+        const resolved = this.resolveToolChannelEntry(channelId, serverId || (trigger?.serverId ?? defaultServer));
+        const entry = resolved.entry;
         if (!entry) {
             return {
                 success: false,
-                error: `Channel not found: ${channelId}`,
+                error: trigger !== undefined
+                    ? `Channel ${channelId} is no longer registered by the server whose message brought you there, so nothing was published.`
+                    : defaultServer !== undefined
+                        ? `Channel ${channelId}, which this call took as its default, is no longer registered by the server whose message set that default, so nothing was published.`
+                        : resolved.error,
                 isError: true,
             };
         }