@moltzap/client 2026.511.1 → 2026.519.0

package/dist/channel-core.js

@@ -2,27 +2,12 @@
  * Shared message-enrichment helper for MoltZap channel adapters.
  */
 import { Cause, Chunk, Deferred, Duration, Effect, Fiber, Queue } from "effect";
-const noopLogger = {
-    info: () => { },
-    warn: () => { },
-    error: () => { },
-};
+import { DispatchAdmissionTimedOut, DispatchLeaseExpired, } from "./channel-core-errors.js";
+import { enrichChannelMessage } from "./channel-core-enrichment.js";
 const DEFAULT_DISPATCH_ADMISSION_TIMEOUT_MS = 30_000;
 const DEFAULT_DISPATCH_LEASE_TIMEOUT_MS = 90_000;
 const DISPATCH_RELEASE_RING_CAPACITY = 256;
 const DISPATCH_RELEASE_RING_SOFT_TTL_MS = 30_000;
-class DispatchLeaseExpired extends Error {
-    messageId;
-    conversationId;
-    timeoutMs;
-    constructor(messageId, conversationId, timeoutMs) {
-        super(`dispatch lease expired after ${timeoutMs}ms`);
-        this.messageId = messageId;
-        this.conversationId = conversationId;
-        this.timeoutMs = timeoutMs;
-        this.name = "DispatchLeaseExpired";
-    }
-}
 function errorSummary(err) {
     if (err instanceof Error) {
         return {
@@ -35,11 +20,17 @@ function errorSummary(err) {
         errorValue: String(err),
     };
 }
-function extractTextContent(parts) {
-    return parts
-        .filter((p) => p.type === "text")
-        .map((p) => p.text)
-        .join("\n");
+function effectLogInfo(message, annotations) {
+    return Effect.logInfo(message).pipe(Effect.annotateLogs(annotations));
+}
+function effectLogWarning(message, annotations) {
+    return Effect.logWarning(message).pipe(Effect.annotateLogs(annotations));
+}
+function effectLogError(message, annotations) {
+    return Effect.logError(message).pipe(Effect.annotateLogs(annotations));
+}
+function runBackgroundLog(effect) {
+    Effect.runFork(effect);
 }
 /**
  * Wraps a MoltZapService with message enrichment, dispatch-chain ordering,
@@ -51,7 +42,6 @@ function extractTextContent(parts) {
  */
 export class MoltZapChannelCore {
     service;
-    logger;
     dispatchAdmissionTimeoutMs;
     connected = false;
     inboundHandler = null;
@@ -82,23 +72,31 @@ export class MoltZapChannelCore {
     closedConversationIds = new Set();
     logicalClocks = new Map();
     parkedByConversation = new Map();
-    /** Inbound messages enqueue synchronously; a single forked consumer fiber
-     * serialises delivery so handlers execute one-at-a-time in arrival order. */
+    /**
+     * Inbound messages enqueue synchronously; a single forked consumer fiber
+     * serialises delivery so handlers execute one-at-a-time in arrival order.
+     */
     inboundQueue = Effect.runSync(Queue.unbounded());
     consumerFiber;
     disconnectHandlers = [];
     reconnectHandlers = [];
     constructor(opts) {
         this.service = opts.service;
-        this.logger = opts.logger ?? noopLogger;
         this.dispatchAdmissionTimeoutMs =
             opts.dispatchAdmissionTimeoutMs ?? DEFAULT_DISPATCH_ADMISSION_TIMEOUT_MS;
+        this.registerMessageListener();
+        this.consumerFiber = this.startConsumerFiber();
+        this.registerConnectionListeners();
+        this.registerConversationLifecycleListeners();
+        this.registerDispatchReleaseListener();
+    }
+    registerMessageListener() {
         this.service.on("message", (message) => {
             if (this.closedConversationIds.has(message.conversationId)) {
-                this.logger.info({
+                runBackgroundLog(effectLogInfo("MoltZapChannelCore: dropping inbound message for closed conversation", {
                     messageId: message.id,
                     conversationId: message.conversationId,
-                }, "MoltZapChannelCore: dropping inbound message for closed conversation");
+                }));
                 return;
             }
             Queue.unsafeOffer(this.inboundQueue, {
@@ -108,17 +106,20 @@ export class MoltZapChannelCore {
                 clock: this.observeMessage(message),
             });
         });
-        // Both typed failures (Effect.fail) and defects (sync throws inside the
-        // handler's Effect) are caught — Cause.squash collapses either into a
-        // single value for the logger so the consumer fiber survives a misbehaving
-        // handler in either mode.
-        const consumer = Effect.forever(Queue.take(this.inboundQueue).pipe(Effect.flatMap((work) => this.dispatchInboundWork(work).pipe(Effect.catchAllCause((cause) => Effect.sync(() => this.logger.error({
+    }
+    startConsumerFiber() {
+        const consumer = Effect.forever(Queue.take(this.inboundQueue).pipe(Effect.flatMap((work) => this.dispatchInboundWork(work).pipe(Effect.catchAllCause((cause) => this.logInboundFailure(work, cause))))));
+        return Effect.runFork(consumer);
+    }
+    logInboundFailure(work, cause) {
+        return effectLogError("MoltZapChannelCore: inbound handler failed", {
             messageId: work.message.id,
             conversationId: work.message.conversationId,
             causePretty: Cause.pretty(cause),
             ...errorSummary(Cause.squash(cause)),
-        }, "MoltZapChannelCore: inbound handler failed")))))));
-        this.consumerFiber = Effect.runFork(consumer);
+        });
+    }
+    registerConnectionListeners() {
         this.service.on("disconnect", () => {
             this.connected = false;
             this.fanout(this.disconnectHandlers, "disconnect");
@@ -127,12 +128,16 @@ export class MoltZapChannelCore {
             this.connected = true;
             this.fanout(this.reconnectHandlers, "reconnect");
         });
+    }
+    registerConversationLifecycleListeners() {
         this.service.on("conversationArchived", ({ conversationId }) => {
             this.closeConversation(conversationId);
         });
         this.service.on("conversationUnarchived", ({ conversationId }) => {
             this.closedConversationIds.delete(conversationId);
         });
+    }
+    registerDispatchReleaseListener() {
         this.service.on("dispatchRelease", (frame) => {
             this.recordDispatchRelease(frame);
         });
@@ -170,7 +175,7 @@ export class MoltZapChannelCore {
             if (oldest === undefined)
                 break;
             this.pendingReleasesByLease.delete(oldest);
-            this.logger.warn({ leaseId: oldest }, "MoltZapChannelCore: dispatchRelease ring buffer evicted oldest entry (capacity reached)");
+            runBackgroundLog(effectLogWarning("MoltZapChannelCore: dispatchRelease ring buffer evicted oldest entry (capacity reached)", { leaseId: oldest }));
         }
     }
     evictDispatchReleaseRing(nowMs) {
@@ -181,7 +186,7 @@ export class MoltZapChannelCore {
                 return;
             }
             this.pendingReleasesByLease.delete(leaseId);
-            this.logger.warn({ leaseId, ageMs: nowMs - entry.receivedAtMs }, "MoltZapChannelCore: dispatchRelease ring buffer evicted stale entry (soft TTL)");
+            runBackgroundLog(effectLogWarning("MoltZapChannelCore: dispatchRelease ring buffer evicted stale entry (soft TTL)", { leaseId, ageMs: nowMs - entry.receivedAtMs }));
         }
     }
     consumeDispatchRelease(leaseId) {
@@ -207,7 +212,10 @@ export class MoltZapChannelCore {
                 h();
             }
             catch (err) {
-                this.logger.error({ err, label }, `MoltZapChannelCore: ${label} handler threw`);
+                runBackgroundLog(effectLogError(`MoltZapChannelCore: ${label} handler threw`, {
+                    err,
+                    label,
+                }));
             }
         }
     }
@@ -231,7 +239,7 @@ export class MoltZapChannelCore {
     sendReply(conversationId, text, opts) {
         if (this.closedConversationIds.has(conversationId) ||
             this.service.isConversationArchived?.(conversationId)) {
-            return Effect.sync(() => this.logger.info({ conversationId }, "MoltZapChannelCore: dropping reply for closed conversation"));
+            return effectLogInfo("MoltZapChannelCore: dropping reply for closed conversation", { conversationId });
         }
         return this.service.send(conversationId, text, {
             dispatchLeaseId: opts?.dispatchLeaseId ?? this.leaseIdInFlight,
@@ -250,10 +258,10 @@ export class MoltZapChannelCore {
                 Queue.unsafeOffer(this.inboundQueue, work);
             }
         }
-        this.logger.info({
+        runBackgroundLog(effectLogInfo("MoltZapChannelCore: closed conversation dispatch work purged", {
             conversationId,
             droppedQueued,
-        }, "MoltZapChannelCore: closed conversation dispatch work purged");
+        }));
     }
     observeMessage(message) {
         const current = this.logicalClocks.get(message.conversationId) ?? {
@@ -337,14 +345,16 @@ export class MoltZapChannelCore {
         // timeouts independently.
         Effect.timeoutFail({
             duration: Duration.millis(this.dispatchAdmissionTimeoutMs),
-            onTimeout: () => new Error(`dispatch request timed out after ${this.dispatchAdmissionTimeoutMs}ms`),
-        }), Effect.flatMap(({ leaseId }) => this.awaitDispatchRelease(work, leaseId)), Effect.catchAll((err) => Effect.sync(() => {
-            this.logger.warn({
+            onTimeout: () => new DispatchAdmissionTimedOut({
+                timeoutMs: this.dispatchAdmissionTimeoutMs,
+            }),
+        }), Effect.flatMap(({ leaseId }) => this.awaitDispatchRelease(work, leaseId)), Effect.catchAll((err) => Effect.gen(function* () {
+            yield* effectLogWarning("MoltZapChannelCore: dispatch admission failed closed", {
                 messageId: work.message.id,
                 conversationId: work.message.conversationId,
                 attempt: work.attempt,
                 err,
-            }, "MoltZapChannelCore: dispatch admission failed closed");
+            });
             return {
                 _tag: "deny",
                 reason: "dispatch admission unavailable",
@@ -374,12 +384,12 @@ export class MoltZapChannelCore {
                 this.pendingDispatchesByLease.delete(leaseId);
             })));
             if (settled._tag === "None") {
-                this.logger.warn({
+                yield* effectLogWarning("MoltZapChannelCore: dispatchRelease wait timed out - fail-closed deny", {
                     messageId: work.message.id,
                     conversationId: work.message.conversationId,
                     leaseId,
                     timeoutMs: this.dispatchAdmissionTimeoutMs,
-                }, "MoltZapChannelCore: dispatchRelease wait timed out — fail-closed deny");
+                });
                 return {
                     _tag: "deny",
                     reason: "dispatch release wait timed out",
@@ -389,135 +399,184 @@ export class MoltZapChannelCore {
         });
     }
     projectVerdict(work, leaseId, verdict) {
-        if (verdict.decision === "grant") {
-            this.logger.info({
-                messageId: work.message.id,
-                conversationId: work.message.conversationId,
-                attempt: work.attempt,
-                leaseId,
-                leaseTimeoutMs: verdict.leaseTimeoutMs,
-                dispatchMessageId: verdict.dispatchMessageId,
-            }, "MoltZapChannelCore: dispatch admission granted");
-            const grant = {
-                _tag: "grant",
-                leaseId: verdict.leaseId ?? leaseId,
-                ...(verdict.leaseTimeoutMs !== undefined
-                    ? { leaseTimeoutMs: verdict.leaseTimeoutMs }
-                    : {}),
-                ...(verdict.dispatchMessageId
-                    ? { dispatchMessageId: verdict.dispatchMessageId }
-                    : {}),
-            };
-            return grant;
-        }
-        if (verdict.decision === "deny") {
-            return {
-                _tag: "deny",
-                ...(verdict.reason !== undefined ? { reason: verdict.reason } : {}),
-            };
+        switch (verdict.decision) {
+            case "grant":
+                return this.projectGrantVerdict(work, leaseId, verdict);
+            case "deny":
+                return MoltZapChannelCore.denyDecision(verdict.reason);
+            case "hold":
+                return MoltZapChannelCore.holdDecision(verdict.reason);
         }
+    }
+    projectGrantVerdict(work, leaseId, verdict) {
+        runBackgroundLog(effectLogInfo("MoltZapChannelCore: dispatch admission granted", {
+            messageId: work.message.id,
+            conversationId: work.message.conversationId,
+            attempt: work.attempt,
+            leaseId,
+            leaseTimeoutMs: verdict.leaseTimeoutMs,
+            dispatchMessageId: verdict.dispatchMessageId,
+        }));
+        return {
+            _tag: "grant",
+            leaseId: verdict.leaseId ?? leaseId,
+            ...(verdict.leaseTimeoutMs !== undefined
+                ? { leaseTimeoutMs: verdict.leaseTimeoutMs }
+                : {}),
+            ...(verdict.dispatchMessageId
+                ? { dispatchMessageId: verdict.dispatchMessageId }
+                : {}),
+        };
+    }
+    static denyDecision(reason) {
+        return {
+            _tag: "deny",
+            ...(reason !== undefined ? { reason } : {}),
+        };
+    }
+    static holdDecision(reason) {
         return {
             _tag: "hold",
-            ...(verdict.reason !== undefined ? { reason: verdict.reason } : {}),
+            ...(reason !== undefined ? { reason } : {}),
         };
     }
     dispatchInboundWork(work) {
         return Effect.gen(this, function* () {
             const current = this.takeDispatchCandidate(work);
             if (this.closedConversationIds.has(current.message.conversationId)) {
-                yield* Effect.sync(() => this.logger.info({
-                    messageId: current.message.id,
-                    conversationId: current.message.conversationId,
-                    attempt: current.attempt,
-                }, "MoltZapChannelCore: dropping dispatch for closed conversation"));
+                yield* this.logClosedDispatchDrop(current);
                 return;
             }
             const decision = yield* this.dispatchAdmission(current);
-            if (decision._tag === "grant") {
-                const messages = this.service.requestDispatch
-                    ? yield* this.takeCoalescedConversationMessages(current, decision.dispatchMessageId)
-                    : [current.message];
-                if (messages.length === 0) {
-                    yield* Effect.sync(() => this.logger.warn({
-                        messageId: current.message.id,
-                        conversationId: current.message.conversationId,
-                        attempt: current.attempt,
-                        dispatchMessageId: decision.dispatchMessageId,
-                    }, "MoltZapChannelCore: dispatch admission target unavailable"));
-                    return;
-                }
-                const primaryMessage = messages[0];
-                yield* Effect.sync(() => this.logger.info({
-                    messageId: primaryMessage.id,
-                    admittedMessageId: current.message.id,
-                    conversationId: current.message.conversationId,
-                    attempt: current.attempt,
-                    leaseId: decision.leaseId,
-                    coalescedMessageCount: messages.length,
-                }, "MoltZapChannelCore: inbound dispatch starting"));
-                const dispatch = Effect.acquireUseRelease(Effect.sync(() => {
-                    const previous = this.leaseIdInFlight;
-                    this.leaseIdInFlight = decision.leaseId;
-                    return previous;
-                }), () => this.dispatchInboundEffect(messages), (previous) => Effect.sync(() => {
-                    this.leaseIdInFlight = previous;
-                }));
-                const timeoutMs = decision.leaseId
-                    ? (decision.leaseTimeoutMs ?? DEFAULT_DISPATCH_LEASE_TIMEOUT_MS)
-                    : undefined;
-                let dispatchTimedOut = false;
-                if (timeoutMs === undefined) {
-                    yield* dispatch;
-                }
-                else {
-                    yield* dispatch.pipe(Effect.timeoutFail({
-                        duration: Duration.millis(timeoutMs),
-                        onTimeout: () => new DispatchLeaseExpired(primaryMessage.id, primaryMessage.conversationId, timeoutMs),
-                    }), Effect.catchAll((err) => {
-                        if (err instanceof DispatchLeaseExpired) {
-                            return Effect.sync(() => {
-                                dispatchTimedOut = true;
-                                this.logger.warn({
-                                    messageId: err.messageId,
-                                    conversationId: err.conversationId,
-                                    attempt: current.attempt,
-                                    leaseId: decision.leaseId,
-                                    timeoutMs: err.timeoutMs,
-                                }, "MoltZapChannelCore: inbound dispatch lease expired");
-                            });
-                        }
-                        return Effect.fail(err);
-                    }));
-                }
-                if (!dispatchTimedOut) {
-                    yield* Effect.sync(() => this.logger.info({
-                        messageId: primaryMessage.id,
-                        admittedMessageId: current.message.id,
-                        conversationId: current.message.conversationId,
-                        attempt: current.attempt,
-                        leaseId: decision.leaseId,
-                    }, "MoltZapChannelCore: inbound dispatch completed"));
-                }
+            yield* this.handleDispatchDecision(current, decision);
+        });
+    }
+    handleDispatchDecision(current, decision) {
+        switch (decision._tag) {
+            case "grant":
+                return this.dispatchGrantedWork(current, decision);
+            case "deny":
+                return this.logDeniedDispatch(current, decision);
+            case "hold":
+                return this.holdDispatchWork(current, decision);
+        }
+    }
+    dispatchGrantedWork(current, decision) {
+        return Effect.gen(this, function* () {
+            const messages = yield* this.messagesForGrantedDispatch(current, decision);
+            if (messages.length === 0) {
+                yield* this.logDispatchTargetUnavailable(current, decision);
                 return;
             }
-            if (decision._tag === "deny") {
-                yield* Effect.sync(() => this.logger.info({
-                    messageId: current.message.id,
-                    conversationId: current.message.conversationId,
-                    attempt: current.attempt,
-                    reason: decision.reason,
-                }, "MoltZapChannelCore: inbound dispatch denied"));
-                return;
+            const primaryMessage = messages[0];
+            yield* this.logDispatchStart(current, primaryMessage, messages, decision);
+            const timedOut = yield* this.runGrantedDispatch(current, primaryMessage, messages, decision);
+            if (!timedOut) {
+                yield* this.logDispatchCompleted(current, primaryMessage, decision);
             }
-            yield* Effect.sync(() => this.logger.info({
+        });
+    }
+    messagesForGrantedDispatch(current, decision) {
+        return this.service.requestDispatch
+            ? this.takeCoalescedConversationMessages(current, decision.dispatchMessageId)
+            : Effect.succeed([current.message]);
+    }
+    runGrantedDispatch(current, primaryMessage, messages, decision) {
+        const dispatch = this.dispatchWithLease(messages, decision.leaseId);
+        const timeoutMs = MoltZapChannelCore.leaseTimeoutMs(decision);
+        if (timeoutMs === undefined)
+            return dispatch.pipe(Effect.as(false));
+        return dispatch.pipe(Effect.timeoutFail({
+            duration: Duration.millis(timeoutMs),
+            onTimeout: () => new DispatchLeaseExpired({
+                messageId: primaryMessage.id,
+                conversationId: primaryMessage.conversationId,
+                timeoutMs,
+            }),
+        }), Effect.as(false), Effect.catchAll((err) => this.handleDispatchFailure(err, current, decision)));
+    }
+    dispatchWithLease(messages, leaseId) {
+        return Effect.sync(() => {
+            const previous = this.leaseIdInFlight;
+            this.leaseIdInFlight = leaseId;
+            return previous;
+        }).pipe(Effect.flatMap((previous) => this.dispatchInboundEffect(messages).pipe(Effect.ensuring(Effect.sync(() => {
+            this.leaseIdInFlight = previous;
+        })))));
+    }
+    static leaseTimeoutMs(decision) {
+        return decision.leaseId
+            ? (decision.leaseTimeoutMs ?? DEFAULT_DISPATCH_LEASE_TIMEOUT_MS)
+            : undefined;
+    }
+    handleDispatchFailure(err, current, decision) {
+        if (err instanceof DispatchLeaseExpired) {
+            return this.logDispatchLeaseExpired(err, current, decision);
+        }
+        return Effect.fail(err);
+    }
+    holdDispatchWork(current, decision) {
+        return Effect.gen(this, function* () {
+            yield* effectLogInfo("MoltZapChannelCore: inbound dispatch held", {
                 messageId: current.message.id,
                 conversationId: current.message.conversationId,
                 attempt: current.attempt,
                 reason: decision.reason,
-            }, "MoltZapChannelCore: inbound dispatch held"));
+            });
             this.parkDispatchWork(current);
         });
     }
+    logClosedDispatchDrop(current) {
+        return effectLogInfo("MoltZapChannelCore: dropping dispatch for closed conversation", {
+            messageId: current.message.id,
+            conversationId: current.message.conversationId,
+            attempt: current.attempt,
+        });
+    }
+    logDispatchTargetUnavailable(current, decision) {
+        return effectLogWarning("MoltZapChannelCore: dispatch admission target unavailable", {
+            messageId: current.message.id,
+            conversationId: current.message.conversationId,
+            attempt: current.attempt,
+            dispatchMessageId: decision.dispatchMessageId,
+        });
+    }
+    logDispatchStart(current, primaryMessage, messages, decision) {
+        return effectLogInfo("MoltZapChannelCore: inbound dispatch starting", {
+            messageId: primaryMessage.id,
+            admittedMessageId: current.message.id,
+            conversationId: current.message.conversationId,
+            attempt: current.attempt,
+            leaseId: decision.leaseId,
+            coalescedMessageCount: messages.length,
+        });
+    }
+    logDispatchLeaseExpired(err, current, decision) {
+        return effectLogWarning("MoltZapChannelCore: inbound dispatch lease expired", {
+            messageId: err.messageId,
+            conversationId: err.conversationId,
+            attempt: current.attempt,
+            leaseId: decision.leaseId,
+            timeoutMs: err.timeoutMs,
+        }).pipe(Effect.as(true));
+    }
+    logDispatchCompleted(current, primaryMessage, decision) {
+        return effectLogInfo("MoltZapChannelCore: inbound dispatch completed", {
+            messageId: primaryMessage.id,
+            admittedMessageId: current.message.id,
+            conversationId: current.message.conversationId,
+            attempt: current.attempt,
+            leaseId: decision.leaseId,
+        });
+    }
+    logDeniedDispatch(current, decision) {
+        return effectLogInfo("MoltZapChannelCore: inbound dispatch denied", {
+            messageId: current.message.id,
+            conversationId: current.message.conversationId,
+            attempt: current.attempt,
+            reason: decision.reason,
+        });
+    }
     pendingDispatchSnapshot(active) {
         const queued = Chunk.toReadonlyArray(Effect.runSync(Queue.takeAll(this.inboundQueue)));
         for (const work of queued) {
@@ -568,89 +627,7 @@ export class MoltZapChannelCore {
      * `resolveAgentName` throws (e.g. service not yet connected).
      */
     static enrichMessage(service, messageOrMessages) {
-        return Effect.gen(function* () {
-            const messages = Array.isArray(messageOrMessages)
-                ? [...messageOrMessages]
-                : [messageOrMessages];
-            const message = messages[0];
-            const convMeta = service.getConversation(message.conversationId);
-            const senderNameFor = (agentId) => {
-                const cachedName = service.getAgentName(agentId);
-                // `resolveAgentName` has `never` in the error channel — it catches its
-                // own transport failures and falls back to `senderId` internally, so
-                // no explicit `catchAll` is needed here.
-                return cachedName !== undefined
-                    ? Effect.succeed(cachedName)
-                    : service.resolveAgentName(agentId);
-            };
-            const senderName = yield* senderNameFor(message.senderId);
-            const coalesced = [];
-            for (const [index, m] of messages.entries()) {
-                const name = index === 0 ? senderName : yield* senderNameFor(m.senderId);
-                coalesced.push({
-                    id: m.id,
-                    sender: {
-                        id: m.senderId,
-                        name,
-                    },
-                    text: extractTextContent(m.parts),
-                    createdAt: m.createdAt,
-                    ...(m.replyToId ? { replyToId: m.replyToId } : {}),
-                });
-            }
-            const text = coalesced.length === 1
-                ? coalesced[0].text
-                : coalesced
-                    .map((m, index) => index === 0
-                    ? m.text
-                    : `[queued message from ${m.sender.name} at ${m.createdAt}]\n${m.text}`)
-                    .join("\n\n");
-            const isFromMe = service.ownAgentId !== undefined &&
-                message.senderId === service.ownAgentId;
-            const conversationMeta = convMeta
-                ? {
-                    type: convMeta.type === "group" ? "group" : "dm",
-                    name: convMeta.name,
-                    participants: convMeta.participants,
-                }
-                : undefined;
-            const contextBlocks = {};
-            if (conversationMeta?.type === "group") {
-                contextBlocks.groupMetadata = conversationMeta;
-            }
-            const { entries, commit: commitLegacy } = service.peekContextEntries(message.conversationId);
-            if (entries.length > 0) {
-                contextBlocks.crossConversation = entries;
-            }
-            const { messages: fullMessages, commit: commitFull } = service.peekFullMessages(message.conversationId);
-            if (fullMessages.length > 0) {
-                contextBlocks.crossConversationMessages = fullMessages;
-            }
-            const hasContext = entries.length > 0 || fullMessages.length > 0;
-            return {
-                enriched: {
-                    id: message.id,
-                    conversationId: message.conversationId,
-                    sender: {
-                        id: message.senderId,
-                        name: senderName,
-                    },
-                    text,
-                    isFromMe,
-                    createdAt: message.createdAt,
-                    replyToId: message.replyToId,
-                    conversationMeta,
-                    contextBlocks,
-                    ...(coalesced.length > 1 ? { coalescedMessages: coalesced } : {}),
-                },
-                commitContext: hasContext
-                    ? () => {
-                        commitLegacy();
-                        commitFull();
-                    }
-                    : undefined,
-            };
-        });
+        return enrichChannelMessage(service, messageOrMessages);
     }
     dispatchInboundEffect(messages) {
         return Effect.gen(this, function* () {