@zhin.js/core 1.5.10 → 1.5.12

package/lib/plugin-runtime/im/im-runtime.js

@@ -2,38 +2,96 @@ import { createToken, generationAdmissionBinder, htmlRendererToken, } from '@zhi
 import { createPermissionHost, permissionHostToken } from '@zhin.js/permission';
 import { MessageBus, messageBusToken } from './message-bus.js';
 import { adapterFeatureId, isAdapterIndex, endpointControlOf, resolveEndpointManagement, } from '@zhin.js/adapter';
-import { isDeliveryReceipt, } from '@zhin.js/im-contract';
+import { MemoryConversationEventStore, conversationRefKey, messageRefKey, } from '@zhin.js/im-contract';
+import { segmentsToPlainText } from '../../built/segment-contract/text.js';
 import { isMiddlewareIndex, middlewareFeatureId } from '@zhin.js/middleware';
 import { isHandlerIndex, handlerFeatureId } from '../../feature/handler.js';
 import { formatCompact, getLogger, truncatePreview } from '@zhin.js/logger';
 import { Message, createOutboundEnvelope, } from './contracts.js';
+import { sideEventGatewayToken, } from './side-event-gateway.js';
+import { loginAssistToken } from './login-assist-host.js';
+import { LoginAssist } from '../../built/login-assist.js';
+import { sideEventSendChannel } from '../../side-event/base.js';
 import { defaultCommandPrefixResolver, MessageDispatcher } from './message-dispatcher.js';
 import { OutboundRenderer } from './outbound-renderer.js';
-import { applyOutboundInteractivePolicy, normalizeOutboundPayload, resolveOutboundInteractivePolicy, resolveOutboundMediaPolicy, } from './outbound-segments.js';
+import { applyOutboundInteractivePolicy, applyOutboundMarkdownPolicy, normalizeOutboundPayload, resolveOutboundInteractivePolicy, resolveOutboundMarkdownPolicy, resolveOutboundMediaPolicy, } from './outbound-segments.js';
 import { assertCanonicalSegments } from '../../built/segment-contract/assert.js';
 import { keyboardFallbackStore } from '../../built/interactive-segments/fallback-store.js';
+import { assertUserInteractionRequest, parseUserInteractionAnswer, projectUserInteraction, renderUserInteraction, } from '../../built/user-interaction.js';
 import { findRuntimeInteractiveHandler, resolveRuntimeInteractivePayload, runtimeInteractiveConversationKey, } from './interactive.js';
 const logger = getLogger('im');
 export const messageGatewayToken = createToken('zhin.im.message-gateway');
 export const ingressRouteToken = createToken('zhin.im.ingress-route');
 export const messagePreviewLimit = 200;
+class UserInteractionTimeoutError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'UserInteractionTimeoutError';
+    }
+}
+class UserInteractionSupersededError extends Error {
+    constructor() {
+        super('User interaction superseded');
+        this.name = 'UserInteractionSupersededError';
+    }
+}
+class UserInteractionDeliveryError extends Error {
+    constructor(receipt) {
+        super(`User interaction delivery failed: ${receipt.failure?.code ?? receipt.status}`);
+        this.name = 'UserInteractionDeliveryError';
+    }
+}
 export class ImRuntime {
     #dispatcher;
     #renderer;
     #messageListeners = new Set();
     #interactiveHandlers = [];
-    #promptClaims = new Map();
+    #interactionClaims = new Map();
     #snapshots;
     #inboundClaim;
     #enrichSender;
+    conversationEvents;
     constructor(options = {}) {
         this.#dispatcher = new MessageDispatcher(options.commandPrefix === undefined
             ? defaultCommandPrefixResolver
             : () => options.commandPrefix ?? '');
         this.#renderer = options.renderer ?? new OutboundRenderer();
+        this.conversationEvents = options.conversationEvents ?? new MemoryConversationEventStore();
         this.#inboundClaim = options.inboundClaim;
         this.#enrichSender = options.enrichSender;
     }
+    /** Process composition replaces the bootstrap memory store after required DB activation. */
+    replaceConversationEventStore(store) {
+        this.conversationEvents = store;
+    }
+    async resolveConversationReference(lease, reference, context) {
+        if (!this.#snapshots?.owns(lease) || !lease.active) {
+            return Object.freeze({ status: 'expired', code: 'generation_lease_expired' });
+        }
+        if (reference.kind === 'message') {
+            const local = await this.conversationEvents.getMessage(reference.message);
+            if (local)
+                return Object.freeze({ status: 'resolved', reference, value: local });
+        }
+        context.signal.throwIfAborted();
+        const conversation = reference.kind === 'message' ? reference.message.conversation : reference.conversation;
+        return requireAdapters(lease.value).resolveContent(conversation.endpoint.id, reference, context);
+    }
+    async readConversationContext(conversation, consumer, throughSequence, limit = 50, excludeMessageId) {
+        if (!Number.isSafeInteger(throughSequence) || throughSequence < 0) {
+            throw new TypeError('Conversation context throughSequence must be a non-negative integer');
+        }
+        const cursor = await this.conversationEvents.getCursor(consumer, conversation);
+        const events = await this.conversationEvents.listBetween(conversation, cursor, throughSequence, limit);
+        const blocks = aggregateConversationContext(events, excludeMessageId);
+        return Object.freeze({
+            blocks: Object.freeze(blocks),
+            cursor: Math.max(cursor, throughSequence),
+        });
+    }
+    async commitConversationContext(conversation, consumer, cursor) {
+        await this.conversationEvents.commitCursor(consumer, conversation, cursor);
+    }
     attach(snapshots) {
         if (this.#snapshots && this.#snapshots !== snapshots) {
             throw new Error('ImRuntime is already attached to another Root');
@@ -42,11 +100,36 @@ export class ImRuntime {
     }
     permissionHost = createPermissionHost();
     messageBus = new MessageBus();
+    loginAssist = new LoginAssist();
     install(resources) {
         resources.provide(messageGatewayToken, this);
+        resources.provide(sideEventGatewayToken, this.#sideEventGateway);
+        resources.provide(loginAssistToken, this.loginAssist);
         resources.provide(permissionHostToken, this.permissionHost);
         resources.provide(messageBusToken, this.messageBus);
     }
+    #sideEventGateway = (() => {
+        const self = this;
+        const gateway = {
+            receiveNotice: (notice) => self.receiveNotice(notice),
+            receiveRequest: (request) => self.receiveRequest(request),
+            receiveSystem: (event) => self.receiveSystem(event),
+            [generationAdmissionBinder](gate) {
+                return Object.freeze({
+                    receiveNotice: async (notice) => {
+                        await gate.enter(() => self.receiveNotice(notice));
+                    },
+                    receiveRequest: async (request) => {
+                        await gate.enter(() => self.receiveRequest(request));
+                    },
+                    receiveSystem: async (event) => {
+                        await gate.enter(() => self.receiveSystem(event));
+                    },
+                });
+            },
+        };
+        return gateway;
+    })();
     [generationAdmissionBinder](gate) {
         const gateway = {
             receive: async (input) => gate.enter(() => this.#receive(input, gate))
@@ -74,18 +157,17 @@ export class ImRuntime {
         };
     }
     // ==========================================================================
-    // Prompt claim — 命令对话式交互
+    // User interaction claim — 命令/Agent 对话式交互
     // ==========================================================================
-    #promptConversationKey(message, subjectId = message.sender?.id ?? '') {
-        const conv = message.conversation;
-        return `${conv.endpoint.adapter}:${conv.endpoint.id}:${conv.kind}:${conv.id}:${subjectId}`;
+    #interactionConversationKey(message, subjectId = message.sender?.id ?? '') {
+        return `${conversationRefKey(message.conversation)}:${subjectId}`;
     }
-    #resolvePromptClaim(message) {
-        const key = this.#promptConversationKey(message);
-        const claim = this.#promptClaims.get(key);
+    #resolveInteractionClaim(message) {
+        const key = this.#interactionConversationKey(message);
+        const claim = this.#interactionClaims.get(key);
         if (!claim)
             return false;
-        claim.resolve(message.content);
+        claim.resolve(resolveRuntimeInteractivePayload(message) ?? message.content);
         return true;
     }
     #claimNextMessage(message, timeout, timeoutText, signal, subjectId) {
@@ -94,146 +176,126 @@ export class ImRuntime {
                 reject(abortError(signal, timeoutText));
                 return;
             }
-            const key = this.#promptConversationKey(message, subjectId);
-            const existing = this.#promptClaims.get(key);
+            const key = this.#interactionConversationKey(message, subjectId);
+            const existing = this.#interactionClaims.get(key);
             if (existing) {
                 clearTimeout(existing.timer);
-                existing.reject(new Error('Prompt superseded'));
+                existing.reject(new UserInteractionSupersededError());
             }
             const timer = setTimeout(() => {
-                settle(undefined, new Error(timeoutText));
+                settle(undefined, new UserInteractionTimeoutError(timeoutText));
             }, timeout);
             const onAbort = () => settle(undefined, abortError(signal, timeoutText));
             signal?.addEventListener('abort', onAbort, { once: true });
             const settle = (value, error) => {
-                if (this.#promptClaims.get(key) !== claim)
+                if (this.#interactionClaims.get(key) !== claim)
                     return;
-                this.#promptClaims.delete(key);
+                this.#interactionClaims.delete(key);
                 clearTimeout(timer);
                 signal?.removeEventListener('abort', onAbort);
                 if (value !== undefined)
                     resolve(value);
                 else
-                    reject(error ?? new Error(timeoutText));
+                    reject(error ?? new UserInteractionTimeoutError(timeoutText));
             };
             const claim = {
                 resolve: (raw) => settle(raw),
                 reject: (error) => settle(undefined, error),
                 timer,
             };
-            this.#promptClaims.set(key, claim);
+            this.#interactionClaims.set(key, claim);
         });
     }
-    #buildCommandPrompt(message, subjectId) {
+    #buildUserInteraction(message, subjectId) {
         const DEFAULT_TIMEOUT = 3 * 60 * 1000;
         const DEFAULT_TIMEOUT_TEXT = '输入超时';
         const claim = (timeout, timeoutText, signal) => this.#claimNextMessage(message, timeout, timeoutText, signal, subjectId);
-        const reply = (content) => message.$reply(content);
-        return {
-            async text(tips, options) {
-                await reply(tips);
-                try {
-                    return await claim(options?.timeout ?? DEFAULT_TIMEOUT, options?.timeoutText ?? DEFAULT_TIMEOUT_TEXT, options?.signal);
-                }
-                catch (e) {
-                    if (options?.default !== undefined)
-                        return options.default;
-                    await reply(e.message);
-                    throw e;
-                }
-            },
-            async number(tips, options) {
-                await reply(tips);
-                try {
-                    const raw = await claim(options?.timeout ?? DEFAULT_TIMEOUT, options?.timeoutText ?? DEFAULT_TIMEOUT_TEXT, options?.signal);
-                    return +raw;
-                }
-                catch (e) {
-                    if (options?.default !== undefined)
-                        return options.default;
-                    await reply(e.message);
-                    throw e;
-                }
-            },
-            async confirm(tips, options) {
-                const condition = options?.condition ?? 'yes';
-                await reply(`${tips}\n输入"${condition}"以确认`);
-                try {
-                    const raw = await claim(options?.timeout ?? DEFAULT_TIMEOUT, options?.timeoutText ?? DEFAULT_TIMEOUT_TEXT, options?.signal);
-                    return raw === condition;
-                }
-                catch (e) {
-                    if (options?.default !== undefined)
-                        return options.default;
-                    await reply(e.message);
-                    throw e;
-                }
-            },
-            async list(tips, options) {
-                const separator = options?.separator ?? ',';
-                await reply(`${tips}\n值之间使用"${separator}"分隔`);
+        const reply = async (view) => {
+            const receipt = await message.$reply(renderUserInteraction(view));
+            if (receipt.status !== 'sent')
+                throw new UserInteractionDeliveryError(receipt);
+        };
+        const ask = async (request, progress) => {
+            assertUserInteractionRequest(request);
+            const timeout = request.timeout ?? DEFAULT_TIMEOUT;
+            const timeoutText = request.timeoutText ?? DEFAULT_TIMEOUT_TEXT;
+            const deadline = Date.now() + timeout;
+            const view = projectUserInteraction(request, progress);
+            await reply(view);
+            while (true) {
                 try {
-                    const raw = await claim(options?.timeout ?? DEFAULT_TIMEOUT, options?.timeoutText ?? DEFAULT_TIMEOUT_TEXT, options?.signal);
-                    const type = options?.type ?? 'text';
-                    return raw.split(separator).map((v) => {
-                        if (type === 'number')
-                            return +v;
-                        if (type === 'boolean')
-                            return v === 'true';
-                        return v;
+                    const raw = await claim(Math.max(1, deadline - Date.now()), timeoutText, request.signal);
+                    const result = parseUserInteractionAnswer(request, raw);
+                    if (result.ok)
+                        return result.value;
+                    await reply({
+                        ...view,
+                        tip: [request.invalidText ?? result.message, view.tip].filter(Boolean).join('\n'),
                     });
                 }
-                catch (e) {
-                    if (options?.default !== undefined)
-                        return options.default;
-                    await reply(e.message);
-                    throw e;
-                }
-            },
-            async pick(tips, options) {
-                const items = options.options.map((o, i) => `${i + 1}.${o.label}`);
-                const separator = options.separator ?? ',';
-                if (options.multiple)
-                    items.push(`多选请用"${separator}"分隔`);
-                await reply(`${tips}\n${items.join('\n')}`);
-                try {
-                    const raw = await claim(options.timeout ?? DEFAULT_TIMEOUT, options.timeoutText ?? DEFAULT_TIMEOUT_TEXT, options.signal);
-                    if (!options.multiple) {
-                        return options.options.find((_, i) => i + 1 === +raw)?.value;
+                catch (error) {
+                    if (error instanceof UserInteractionTimeoutError && 'default' in request && request.default !== undefined) {
+                        return request.default;
                     }
-                    const indices = raw.split(separator).map(Number);
-                    return options.options
-                        .filter((_, i) => indices.includes(i + 1))
-                        .map((o) => o.value);
-                }
-                catch (e) {
-                    if (options.default !== undefined)
-                        return options.default;
-                    await reply(e.message);
-                    throw e;
+                    if (error instanceof UserInteractionTimeoutError) {
+                        await reply({ title: '交互已结束', description: error.message });
+                    }
+                    throw error;
                 }
-            },
+            }
+        };
+        const sequence = async (definition) => {
+            if (!definition.title.trim())
+                throw new TypeError('User interaction sequence title must not be empty');
+            const ids = new Set();
+            for (const step of definition.steps) {
+                if (!step.id.trim())
+                    throw new TypeError('User interaction sequence step id must not be empty');
+                if (ids.has(step.id))
+                    throw new TypeError(`Duplicate user interaction sequence step id: ${step.id}`);
+                ids.add(step.id);
+            }
+            const result = {};
+            for (let index = 0; index < definition.steps.length; index += 1) {
+                const step = definition.steps[index];
+                const request = {
+                    ...step,
+                    timeout: step.timeout ?? definition.timeout,
+                    timeoutText: step.timeoutText ?? definition.timeoutText,
+                    invalidText: step.invalidText ?? definition.invalidText,
+                    signal: step.signal ?? definition.signal,
+                };
+                result[step.id] = await ask(request, {
+                    title: definition.title,
+                    description: definition.description,
+                    tip: definition.tip,
+                    index: index + 1,
+                    total: definition.steps.length,
+                });
+            }
+            return Object.freeze(result);
         };
+        return Object.freeze({ ask, sequence });
     }
     /**
-     * Bound Prompt for this conversation.
+     * User interaction bound to this conversation.
      * `bind.subjectId` waits for that user (e.g. master) instead of the message sender.
      */
-    createPrompt(message, bind) {
+    createInteraction(message, bind) {
         const subjectId = bind?.subjectId?.trim();
         if (bind && !subjectId)
             return undefined;
         if (typeof message.$reply !== 'function' || !message.conversation)
             return undefined;
-        return this.#buildCommandPrompt(message, subjectId);
+        return this.#buildUserInteraction(message, subjectId);
     }
-    #createPromptForSource(source) {
+    #createInteractionForSource(source) {
         if (!source || typeof source !== 'object')
             return undefined;
         const msg = source;
         if (typeof msg.$reply !== 'function' || !msg.conversation)
             return undefined;
-        return this.#buildCommandPrompt(msg);
+        return this.#buildUserInteraction(msg);
     }
     /**
      * 订阅消息事件（入站 dispatch 完成后 / 出站发送成功后回调）。
@@ -293,24 +355,51 @@ export class ImRuntime {
                     },
                 }, lease.value);
             }, enrichedSender, Object.freeze({ ...input.metadata }), input.segments ? Object.freeze([...input.segments]) : undefined, input.message, input.endpointId, input.mentioned, input.replyTo);
-            await runHandlers(lease.value, 'message.receive', message);
+            let conversationSequence;
+            if (input.message?.id) {
+                const appended = await this.conversationEvents.append(Object.freeze({
+                    eventId: `message:${messageRefKey(input.message)}`,
+                    conversation,
+                    timestamp: Date.now(),
+                    type: 'message.created',
+                    message: Object.freeze({
+                        ref: input.message,
+                        ...(enrichedSender ? { actor: Object.freeze({
+                                id: enrichedSender.id,
+                                ...(enrichedSender.name ? { displayName: enrichedSender.name } : {}),
+                            }) } : {}),
+                        segments: Object.freeze(input.segments?.length
+                            ? [...input.segments]
+                            : [{ type: 'text', data: { text: input.content } }]),
+                        timestamp: Date.now(),
+                        ...(input.replyTo ? { replyTo: Object.freeze({ conversation, id: input.replyTo.id }) } : {}),
+                    }),
+                }));
+                conversationSequence = appended.sequence;
+            }
             let result = Object.freeze({ matched: false });
             const claimed = await this.#inboundClaim?.(message) === true;
             if (claimed) {
                 result = Object.freeze({ matched: true, command: 'interaction', owner: requester });
             }
-            else if (this.#resolvePromptClaim(message)) {
-                result = Object.freeze({ matched: true, command: 'prompt', owner: requester });
+            else if (this.#resolveInteractionClaim(message)) {
+                result = Object.freeze({ matched: true, command: 'interaction', owner: requester });
             }
             else {
-                const promptFactory = (source) => this.#createPromptForSource(source);
+                const interactionFactory = (source) => this.#createInteractionForSource(source);
                 await runMiddleware(lease.value, message, async () => {
-                    result = await this.#dispatchInteractive(message, requester, admission)
-                        ?? await this.#dispatcher.dispatch(message, lease.value, promptFactory);
                     const ingressRoute = resolveIngressRoute(lease.value);
+                    const preRouted = await ingressRoute?.preRoute?.(message, lease, requester, conversationSequence) === true;
+                    if (preRouted) {
+                        result = Object.freeze({ matched: true, command: 'pre-route', owner: requester });
+                        return;
+                    }
+                    await this.#runHandlers(lease.value, 'message.receive', [message]);
+                    result = await this.#dispatchInteractive(message, requester, admission)
+                        ?? await this.#dispatcher.dispatch(message, lease.value, interactionFactory);
                     if (!result.matched && ingressRoute) {
                         logger.debug(formatCompact({ op: 'unmatched', conv: formatConversationLog(conversation) }));
-                        const handled = await ingressRoute.route(message, lease, requester);
+                        const handled = await ingressRoute.route(message, lease, requester, conversationSequence);
                         if (handled) {
                             result = Object.freeze({ matched: true, command: 'ai', owner: requester });
                         }
@@ -348,12 +437,108 @@ export class ImRuntime {
             lease.release();
         }
     }
+    async receiveNotice(notice) {
+        const event = conversationEventFromNotice(notice);
+        if (event)
+            await this.conversationEvents.append(event);
+        await this.#receiveSideEvent('notice.receive', notice);
+    }
+    async receiveRequest(request) {
+        await this.#withRequestActionScope(request, async (scoped) => {
+            await this.#receiveSideEvent('request.receive', scoped);
+        });
+    }
+    async #withRequestActionScope(request, dispatch) {
+        let active = true;
+        const actions = new Set();
+        const run = (action) => {
+            if (!active)
+                throw new Error('Request action port expired with its generation operation');
+            const operation = Promise.resolve().then(action);
+            actions.add(operation);
+            void operation.then(() => actions.delete(operation), () => actions.delete(operation));
+            return operation;
+        };
+        const scoped = Object.assign(Object.create(Object.getPrototypeOf(request)), request, {
+            $approve: async (remark) => run(() => request.$approve(remark)),
+            $reject: async (reason) => run(() => request.$reject(reason)),
+        });
+        try {
+            await dispatch(scoped);
+        }
+        finally {
+            active = false;
+            await Promise.allSettled([...actions]);
+        }
+    }
+    async receiveSystem(event) {
+        await this.#receiveSideEvent('system.receive', event);
+    }
+    async #receiveSideEvent(event, payload) {
+        const lease = this.#acquire();
+        try {
+            await this.#runHandlers(lease.value, event, [payload]);
+        }
+        finally {
+            lease.release();
+        }
+    }
+    /**
+     * User interaction bound to a side-event scene (private/group channel derived from
+     * `$scene_type` / `$scene_id`). Returns undefined when outbound is unavailable.
+     */
+    #createInteractionForSideEvent(payload, snapshot) {
+        const adapter = String(payload.$adapter);
+        const endpointKey = String(payload.$endpoint);
+        if (!adapter || !endpointKey)
+            return undefined;
+        const channel = sideEventSendChannel(payload);
+        const conversation = Object.freeze({
+            endpoint: Object.freeze({ adapter, id: endpointKey }),
+            kind: channel.type,
+            id: channel.id || endpointKey,
+        });
+        const requester = snapshot.root;
+        const source = Object.freeze({
+            conversation,
+            ...(payload.$actor?.id
+                ? { sender: Object.freeze({ id: payload.$actor.id }) }
+                : {}),
+            $reply: (content) => this.#sendWithSnapshot({
+                conversation,
+                requester,
+                content,
+            }, snapshot),
+        });
+        return this.#buildUserInteraction(source);
+    }
+    async #runHandlers(snapshot, event, args) {
+        const index = handlers(snapshot);
+        if (!index)
+            return;
+        const options = {
+            resolveInteraction: (name, interactionArgs) => {
+                const payload = interactionArgs[0];
+                if (name === 'message.receive' && payload instanceof Message) {
+                    return this.createInteraction(payload);
+                }
+                if (name === 'notice.receive'
+                    || name === 'request.receive'
+                    || name === 'system.receive') {
+                    return this.#createInteractionForSideEvent(payload, snapshot);
+                }
+                return undefined;
+            },
+        };
+        await index.dispatch(event, args, options);
+    }
     /** Console `endpoint.list` — empty until Adapter Feature projection is ready. */
     listEndpoints() {
         try {
             const lease = this.#acquire();
             try {
                 return requireAdapters(lease.value).describe().map((row) => Object.freeze({
+                    id: String(row.id),
                     name: row.name,
                     // adapter 列显示平台类型（owner 包名去 scope/adapter- 前缀），不是 slot localName
                     adapter: adapterTypeName(lease.value.tree.get(row.owner)?.packageName) ?? row.name,
@@ -450,7 +635,7 @@ export class ImRuntime {
                 requester,
                 content,
             }, lease.value);
-            return { messageId: result.message?.id ?? result.legacyMessageId ?? '' };
+            return { messageId: result.message?.id ?? '' };
         }
         finally {
             lease.release();
@@ -545,19 +730,33 @@ export class ImRuntime {
                         conversation: request.conversation,
                         payload,
                     });
-                    receipt = receiptFromEndpointResult(result);
+                    receipt = receiptFromEndpointResult(result, request.conversation);
                 }
                 catch (error) {
                     receipt = receiptFromEndpointError(error);
                 }
                 if (receipt?.status === 'sent') {
+                    if (receipt.message?.id) {
+                        const segments = conversationSegmentsFromContent(request.content);
+                        await this.conversationEvents.append(Object.freeze({
+                            eventId: `message:${messageRefKey(receipt.message)}`,
+                            conversation: request.conversation,
+                            timestamp: Date.now(),
+                            type: 'message.created',
+                            message: Object.freeze({
+                                ref: receipt.message,
+                                segments,
+                                timestamp: Date.now(),
+                            }),
+                        }));
+                    }
                     this.#emitMessage({
                         direction: 'outbound',
                         conversation: request.conversation,
                         requester: request.requester,
                         contentPreview: previewText(payload),
-                        ...(receipt.message?.id || receipt.legacyMessageId
-                            ? { messageId: receipt.message?.id ?? receipt.legacyMessageId }
+                        ...(receipt.message?.id
+                            ? { messageId: receipt.message.id }
                             : {}),
                         timestamp: Date.now(),
                     });
@@ -608,6 +807,133 @@ export class ImRuntime {
             : undefined;
     }
 }
+function conversationEventFromNotice(notice) {
+    const sceneType = notice.$scene_type;
+    const kind = sceneType === 'group' ? 'group'
+        : sceneType === 'channel' ? 'channel'
+            : sceneType === 'friend' || sceneType === 'private' ? 'private'
+                : undefined;
+    if (!kind || !notice.$scene_id || !notice.$id)
+        return undefined;
+    const conversation = Object.freeze({
+        endpoint: Object.freeze({ adapter: String(notice.$adapter), id: String(notice.$endpoint) }),
+        kind,
+        id: String(notice.$scene_id),
+    });
+    const actor = notice.$actor?.id
+        ? Object.freeze({ id: String(notice.$actor.id), ...(notice.$actor.name ? { displayName: notice.$actor.name } : {}) })
+        : undefined;
+    const target = notice.$target?.id
+        ? Object.freeze({ id: String(notice.$target.id), ...(notice.$target.name ? { displayName: notice.$target.name } : {}) })
+        : undefined;
+    const base = Object.freeze({
+        eventId: `notice:${conversationRefKey(conversation)}:${String(notice.$id)}`,
+        conversation,
+        timestamp: notice.$timestamp,
+    });
+    switch (notice.$sub_type) {
+        case 'member_increase':
+        case 'increase':
+            return target ? Object.freeze({ ...base, type: 'member.joined', member: target, ...(actor ? { actor } : {}) }) : undefined;
+        case 'member_decrease':
+            return target ? Object.freeze({ ...base, type: 'member.left', member: target, ...(actor ? { actor } : {}), reason: actor ? 'removed' : 'left' }) : undefined;
+        case 'ban':
+            if (!target)
+                return undefined;
+            return notice.$duration_seconds === 0
+                ? Object.freeze({ ...base, type: 'member.unmuted', member: target, ...(actor ? { actor } : {}) })
+                : Object.freeze({ ...base, type: 'member.muted', member: target, ...(actor ? { actor } : {}), durationSeconds: notice.$duration_seconds ?? 0 });
+        case 'admin_change':
+            return target && notice.$role && typeof notice.$enabled === 'boolean'
+                ? Object.freeze({ ...base, type: 'member.role_changed', member: target, ...(actor ? { actor } : {}), role: notice.$role, enabled: notice.$enabled })
+                : undefined;
+        case 'recall':
+            return notice.$message_id
+                ? Object.freeze({ ...base, type: 'message.recalled', message: Object.freeze({ conversation, id: notice.$message_id }), ...(actor ? { actor } : {}) })
+                : undefined;
+        case 'emoji_reaction':
+            return notice.$message_id && notice.$reaction && notice.$operation
+                ? Object.freeze({ ...base, type: 'message.reaction_changed', message: Object.freeze({ conversation, id: notice.$message_id }), ...(actor ? { actor } : {}), reaction: notice.$reaction, operation: notice.$operation })
+                : undefined;
+        case 'poke':
+            return Object.freeze({ ...base, type: 'conversation.poked', ...(actor ? { actor } : {}), ...(target ? { target } : {}) });
+        default:
+            return undefined;
+    }
+}
+function describeConversationEvent(event) {
+    const actor = 'actor' in event && event.actor ? `${event.actor.displayName ?? event.actor.id} (${event.actor.id})` : undefined;
+    switch (event.type) {
+        case 'message.recalled': return `${actor ?? 'Someone'} recalled message ${event.message.id}.`;
+        case 'message.reaction_changed': return `${actor ?? 'Someone'} ${event.operation} reaction ${event.reaction} on message ${event.message.id}.`;
+        case 'conversation.poked': return `${actor ?? 'Someone'} poked ${event.target ? `${event.target.displayName ?? event.target.id} (${event.target.id})` : 'someone'}.`;
+        case 'member.joined': return `${event.member.displayName ?? event.member.id} (${event.member.id}) joined the conversation.`;
+        case 'member.left': return `${event.member.displayName ?? event.member.id} (${event.member.id}) left the conversation (${event.reason ?? 'left'}).`;
+        case 'member.muted': return `${event.member.displayName ?? event.member.id} (${event.member.id}) was muted for ${event.durationSeconds} seconds${actor ? ` by ${actor}` : ''}.`;
+        case 'member.unmuted': return `${event.member.displayName ?? event.member.id} (${event.member.id}) was unmuted${actor ? ` by ${actor}` : ''}.`;
+        case 'member.role_changed': return `${event.member.displayName ?? event.member.id} (${event.member.id}) role ${event.role} was ${event.enabled ? 'enabled' : 'disabled'}${actor ? ` by ${actor}` : ''}.`;
+        case 'message.created': return '';
+    }
+}
+function describeConversationMessage(message) {
+    const actor = message.actor
+        ? `${message.actor.displayName ?? message.actor.id} (${message.actor.id})`
+        : undefined;
+    if (!actor)
+        return '';
+    const text = segmentsToPlainText(message.segments).trim();
+    const attachmentTypes = [...new Set(message.segments
+            .filter((segment) => segment.type !== 'text' && segment.type !== 'mention' && segment.type !== 'at')
+            .map((segment) => segment.type))];
+    const attachmentNote = attachmentTypes.length > 0
+        ? ` [message also contains ${attachmentTypes.join(', ')} data; inspect its reference before relying on that content]`
+        : '';
+    return `${actor}: ${text || '(no plain-text content)'}${attachmentNote}`;
+}
+function aggregateConversationContext(events, excludeMessageId) {
+    const ordinary = [];
+    const noisy = new Map();
+    for (const { sequence, event } of events) {
+        if (event.type === 'message.created') {
+            if (event.message.ref.id === excludeMessageId)
+                continue;
+            const text = describeConversationMessage(event.message);
+            if (!text)
+                continue;
+            ordinary.push(Object.freeze({
+                kind: 'conversation_event',
+                sequence,
+                eventType: event.type,
+                text,
+            }));
+            continue;
+        }
+        if (event.type === 'message.reaction_changed' || event.type === 'conversation.poked') {
+            const key = event.type === 'message.reaction_changed'
+                ? `${event.type}:${event.message.id}:${event.actor?.id ?? ''}:${event.reaction}:${event.operation}`
+                : `${event.type}:${event.actor?.id ?? ''}:${event.target?.id ?? ''}`;
+            const previous = noisy.get(key);
+            noisy.set(key, { sequence, event, count: (previous?.count ?? 0) + 1 });
+            continue;
+        }
+        ordinary.push(Object.freeze({
+            kind: 'conversation_event',
+            sequence,
+            eventType: event.type,
+            text: describeConversationEvent(event),
+        }));
+    }
+    for (const { sequence, event, count } of noisy.values()) {
+        ordinary.push(Object.freeze({
+            kind: 'conversation_event',
+            sequence,
+            eventType: event.type,
+            text: `${describeConversationEvent(event)}${count > 1 ? ` (${count} similar events.)` : ''}`,
+        }));
+    }
+    ordinary.sort((left, right) => left.sequence - right.sequence);
+    return Object.freeze(ordinary);
+}
 function resolveIngressRoute(snapshot) {
     const candidate = snapshot.resources.get(snapshot.root)?.get(ingressRouteToken.id);
     return candidate
@@ -641,9 +967,10 @@ function isDirectHtmlConsumer(snapshot, adapter) {
 async function prepareOutboundPayload(rendered, conversation, snapshot, finalizeInteractive = false) {
     const adapter = conversation.endpoint.id;
     const directHtml = isDirectHtmlConsumer(snapshot, adapter);
+    const markdownResolved = applyOutboundMarkdownPolicy(rendered, resolveOutboundMarkdownPolicy(adapter, snapshot));
     let payload = directHtml
-        ? rendered
-        : await normalizeOutboundPayload(rendered, resolveHtmlRenderer(snapshot), {
+        ? markdownResolved
+        : await normalizeOutboundPayload(markdownResolved, resolveHtmlRenderer(snapshot), {
             mediaPolicy: resolveOutboundMediaPolicy(adapter, snapshot),
         });
     if (finalizeInteractive) {
@@ -653,23 +980,12 @@ async function prepareOutboundPayload(rendered, conversation, snapshot, finalize
         assertCanonicalSegments(payload);
     return payload;
 }
-function receiptFromEndpointResult(result) {
-    if (isDeliveryReceipt(result))
-        return result;
-    const legacyMessageId = legacyMessageIdOf(result);
+function receiptFromEndpointResult(messageId, conversation) {
     return Object.freeze({
         status: 'sent',
-        ...(legacyMessageId ? { legacyMessageId } : {}),
+        message: Object.freeze({ conversation, id: messageId }),
     });
 }
-function legacyMessageIdOf(result) {
-    if (typeof result === 'string' || typeof result === 'number')
-        return String(result);
-    if (!result || typeof result !== 'object')
-        return undefined;
-    const id = result.id;
-    return typeof id === 'string' || typeof id === 'number' ? String(id) : undefined;
-}
 function receiptFromEndpointError(error) {
     const message = error instanceof Error ? error.message : String(error);
     if (/Unknown Adapter Endpoint|does not support outbound/u.test(message)) {
@@ -725,11 +1041,6 @@ function handlers(snapshot) {
     const projection = snapshot.projections.get(handlerFeatureId);
     return isHandlerIndex(projection) ? projection : undefined;
 }
-async function runHandlers(snapshot, event, ...args) {
-    const index = handlers(snapshot);
-    if (index)
-        await index.dispatch(event, ...args);
-}
 function normalizeConsoleContent(content) {
     if (typeof content === 'string')
         return content;
@@ -782,6 +1093,18 @@ function flattenContent(content) {
     }
     return String(content);
 }
+function conversationSegmentsFromContent(content) {
+    if (Array.isArray(content)) {
+        try {
+            assertCanonicalSegments(content);
+            return Object.freeze([...content]);
+        }
+        catch {
+            // Fall through to a truthful text projection of non-canonical output.
+        }
+    }
+    return Object.freeze([{ type: 'text', data: Object.freeze({ text: flattenContent(content) }) }]);
+}
 function abortError(signal, fallback) {
     if (signal?.reason instanceof Error)
         return signal.reason;