@mininglamp-oss/octo-runtime 1.0.0 → 1.1.0

package/node_modules/@mininglamp-oss/octo-runtime-extra-channel-gateway/dist/lifecycle/manager.js

@@ -1,6 +1,8 @@
 import { ImRuntime } from "../application/im-channel.js";
+import { HostSessionStore } from "../application/host-session-store.js";
+import { abortForShutdown, shutdownDeadline, shutdownSignal, withShutdownDeadline, withinShutdown } from "@mininglamp-oss/octo-runtime-host-sdk/shutdown";
 import { imBotIdentity, validateImConfig, IM_MAX_BOTS, IM_MAX_CONFIG_OPERATIONS } from "./configuration.js";
-/** Serial updates replace only the target connection. */
+/** 串行替换单个 Bot；工厂句柄归 Manager，只有旧 endpoint 完整释放才允许替换。 */
 export class ImChannelManager {
     dependencies;
     #endpoints = new Map();
@@ -11,9 +13,14 @@ export class ImChannelManager {
     #abort = new AbortController();
     constructor(dependencies) {
         this.dependencies = dependencies;
+        if (dependencies.createSessionStore !== undefined &&
+            typeof dependencies.createSessionStore !== "function")
+            throw new Error("IM_SESSION_STORE_FACTORY_INVALID");
+        if (dependencies.sessions && dependencies.createSessionStore)
+            throw new Error("IM_SESSION_STORE_CONFLICT");
     }
     get status() {
-        return [...this.#endpoints.values()].map((runtime) => ({ ...runtime.status }));
+        return [...this.#endpoints.values()].flatMap(({ runtime }) => runtime ? [{ ...runtime.status }] : []);
     }
     upsert(config) {
         if (this.#closed)
@@ -34,27 +41,75 @@ export class ImChannelManager {
             const current = this.#endpoints.get(key);
             if (!current && this.#endpoints.size >= IM_MAX_BOTS)
                 throw new Error("IM_ENDPOINT_CAPACITY_EXHAUSTED");
-            await current?.close();
+            if (current)
+                await this.#closeEndpoint(current);
             if (this.#closed)
                 throw new Error("IM_MANAGER_CLOSED");
-            const runtime = new ImRuntime(snapshot, {
-                ...this.dependencies,
-                signal: AbortSignal.any([
-                    this.#abort.signal,
-                    ...(this.dependencies.signal ? [this.dependencies.signal] : [])
-                ])
-            });
-            this.#endpoints.set(key, runtime);
-            await runtime.start();
-            return { ...runtime.status };
+            const endpoint = {};
+            // 工厂可能重入 close；先登记空 endpoint，随后创建的句柄也属于这次关闭。
+            this.#endpoints.set(key, endpoint);
+            const signal = shutdownSignal([
+                this.#abort.signal,
+                ...(this.dependencies.signal ? [this.dependencies.signal] : [])
+            ]);
+            try {
+                let sessions = this.dependencies.sessions;
+                if (snapshot.enabled !== false && this.dependencies.createSessionStore) {
+                    endpoint.store = new HostSessionStore(signal);
+                    sessions = endpoint.store.create((config) => this.dependencies.createSessionStore(config), structuredClone(snapshot));
+                }
+                if (this.#closed || signal.aborted)
+                    throw new Error("IM_MANAGER_CLOSED");
+                const runtime = new ImRuntime(snapshot, { ...this.dependencies, signal, sessions });
+                endpoint.runtime = runtime;
+                await runtime.start();
+                return { ...runtime.status };
+            }
+            catch (error) {
+                // 不能因构造或 start 失败遗失已分配句柄；清理失败时原记录继续阻止替换。
+                try {
+                    await this.#closeEndpoint(endpoint);
+                    if (this.#endpoints.get(key) === endpoint)
+                        this.#endpoints.delete(key);
+                }
+                catch {
+                    throw new Error("IM_ENDPOINT_CLEANUP_INCOMPLETE", { cause: error });
+                }
+                throw error;
+            }
         });
     }
     remove(id) {
         return this.#enqueue(async () => {
-            await this.#endpoints.get(id)?.close();
+            const endpoint = this.#endpoints.get(id);
+            if (endpoint)
+                await this.#closeEndpoint(endpoint);
             this.#endpoints.delete(id);
         });
     }
+    #closeEndpoint(endpoint, until = shutdownDeadline(this.dependencies.signal)) {
+        if (endpoint.closing)
+            return endpoint.closing;
+        endpoint.store?.drain(until);
+        endpoint.closing = Promise.resolve().then(async () => {
+            const errors = [];
+            try {
+                await withShutdownDeadline(until, () => withinShutdown(Promise.resolve().then(() => endpoint.runtime?.close()), until, "IM_DISPOSE_FAILED"));
+            }
+            catch (error) {
+                errors.push(error);
+            }
+            try {
+                await endpoint.store?.close(until);
+            }
+            catch (error) {
+                errors.push(error);
+            }
+            if (errors.length)
+                throw new AggregateError(errors, "IM_DISPOSE_FAILED");
+        });
+        return endpoint.closing;
+    }
     #enqueue(operation) {
         if (this.#closed)
             return Promise.reject(new Error("IM_MANAGER_CLOSED"));
@@ -78,10 +133,15 @@ export class ImChannelManager {
             return this.#closing;
         this.#closed = true;
         // Cancel initialization before waiting for the queue it is blocking.
-        this.#abort.abort();
+        const until = shutdownDeadline(this.dependencies.signal);
+        for (const endpoint of this.#endpoints.values())
+            endpoint.store?.drain(until);
+        withShutdownDeadline(until, () => abortForShutdown(this.#abort));
         this.#closing = (async () => {
-            await this.#queue;
-            const results = await Promise.allSettled([...this.#endpoints.values()].map((runtime) => Promise.resolve().then(() => runtime.close())));
+            const results = await Promise.allSettled([
+                withinShutdown(this.#queue, until, "IM_DISPOSE_FAILED"),
+                ...[...this.#endpoints.values()].map((endpoint) => this.#closeEndpoint(endpoint, until))
+            ]);
             const errors = results
                 .filter((result) => result.status === "rejected")
                 .map((result) => result.reason);

package/node_modules/@mininglamp-oss/octo-runtime-extra-channel-gateway/dist/ports.d.ts

@@ -2,15 +2,26 @@
  * 宿主依赖入口：注入执行能力、凭据来源和脱敏诊断。
  * SDK 应用自行决定账号目录和凭据生命周期，通道无需依赖 CLI 或具体 Provider。
  */
-import type { ImBotConfig, ImExecutionPort } from "./contracts.js";
+import type { KernelClient } from "@mininglamp-oss/octo-runtime-executor-kernel";
+import type { ImBotConfig } from "./contracts.js";
 import type { ImSessionStore } from "./application/session-store.js";
-import type { RuntimeLog, JsonObject } from "@mininglamp-oss/octo-runtime-daemon";
+import type { RuntimeLog, JsonObject, ChannelDependencies } from "@mininglamp-oss/octo-runtime-host-sdk";
 import type { ContextItem } from "@mininglamp-oss/octo-runtime-protocol";
 export type ImCredentialSource = (config: ImBotConfig, signal: AbortSignal) => Promise<string | undefined>;
+/** 根据可信 Bot 配置的独立快照同步创建句柄；数据库及其迁移仍归宿主所有。 */
+export type CreateSessionStore = (config: JsonObject) => ImSessionStore;
+/** Gateway 专属依赖；通过同一泛型 Extra 服务注入，不扩展通用 ExtraContext。 */
+export interface GatewayDependencies extends ChannelDependencies {
+    createSessionStore?: CreateSessionStore;
+}
+/** Manager 额外拥有工厂句柄；直接 sessions 仍为借用，不能与工厂同时配置。 */
+export interface ImChannelManagerDependencies extends ImModuleDependencies {
+    createSessionStore?: CreateSessionStore;
+}
 export interface ImModuleDependencies {
     prepareContexts?: (config: JsonObject, signal: AbortSignal) => Promise<ContextItem[]>;
     log?: RuntimeLog;
-    host: ImExecutionPort;
+    kernel: Pick<KernelClient, "invoke" | "cancelInvocation" | "respondInteraction">;
     /** Owning Extra/manager lifetime; aborts connections, execution and delivery. */
     signal?: AbortSignal;
     authorizeSpace?: (spaceId: string) => void;

package/node_modules/@mininglamp-oss/octo-runtime-extra-channel-gateway/dist/presentation/run-projector.js

@@ -240,7 +240,7 @@ export class ImRunProjector {
             text =
                 this.#terminal === "cancelled"
                     ? "本轮执行已中断。"
-                    : `执行失败：${clampRunes(this.#failureDetail || "系统未返回具体原因，请查看运行记录。", 8000)}`;
+                    : `执行失败：${clampRunes(this.#failureDetail || "系统未返回具体原因，请查看运行记录。", 8000)}${failureIdentity(this.#failure)}`;
         this.#finalReply = { text, allowMention };
     }
     get finalReply() {
@@ -273,6 +273,9 @@ export class ImRunProjector {
         };
     }
 }
+function failureIdentity(failure) {
+    return failure ? `\n错误码：${failure.code}\n诊断编号：${failure.diagnosticId}` : "";
+}
 function hasVisibleReply(text) {
     const visible = (value) => !!value.replace(/[\s\p{Default_Ignorable_Code_Point}]/gu, "");
     if (!visible(text))

package/node_modules/@mininglamp-oss/octo-runtime-extra-channel-gateway/dist/transport/api/conversations.d.ts

@@ -57,6 +57,7 @@ export declare function getChannelMessages(params: {
     startMessageSeq?: number;
     endMessageSeq?: number;
     pullMode?: 0 | 1;
+    retryOn429?: boolean;
     signal?: AbortSignal;
     log?: {
         info?: (msg: string) => void;
@@ -73,6 +74,10 @@ export declare function getChannelMessages(params: {
     name?: string;
     payload?: SyncMessagePayload;
 }>>;
+export declare function getChannelMessagePage(params: Parameters<typeof getChannelMessages>[0]): Promise<{
+    messages: Awaited<ReturnType<typeof getChannelMessages>>;
+    more?: boolean;
+}>;
 /**
  * Fetch user info by UID. Requires backend `/v1/bot/user/info` endpoint.
  * Returns null if the endpoint is unavailable (404) or returns an error,

package/node_modules/@mininglamp-oss/octo-runtime-extra-channel-gateway/dist/transport/api/conversations.js

@@ -31,6 +31,9 @@ export async function getGroupMembers(params) {
  * @param params.log - Optional logger for consistent logging with OpenClaw log system
  */
 export async function getChannelMessages(params) {
+    return (await getChannelMessagePage(params)).messages;
+}
+export async function getChannelMessagePage(params) {
     const limit = params.limit ?? 20;
     const data = await postJson(params.apiUrl, params.botToken, "/v1/bot/messages/sync", {
         channel_id: params.channelId,
@@ -42,11 +45,13 @@ export async function getChannelMessages(params) {
     }, AbortSignal.any([
         AbortSignal.timeout(DEFAULT_TIMEOUT_MS),
         ...(params.signal ? [params.signal] : [])
-    ]), { maxResponseBytes: 1 << 20, logRateLimit: false });
+    ]), { maxResponseBytes: 1 << 20, logRateLimit: false, retryOn429: params.retryOn429 });
     if (!Array.isArray(data?.messages))
         throw new Error("IM_HISTORY_PROTOCOL_INVALID");
+    if (data.more !== undefined && ![true, false, 0, 1].includes(data.more))
+        throw new Error("IM_HISTORY_PROTOCOL_INVALID");
     const messages = data.messages;
-    return messages.map((m) => {
+    const decoded = messages.map((m) => {
         // payload is base64-encoded JSON string
         let payload = {};
         if (m.payload) {
@@ -75,6 +80,7 @@ export async function getChannelMessages(params) {
             timestamp: (m.timestamp ?? Math.floor(Date.now() / 1000)) * 1000
         };
     });
+    return { messages: decoded, ...(data.more !== undefined ? { more: Boolean(data.more) } : {}) };
 }
 /**
  * Fetch user info by UID. Requires backend `/v1/bot/user/info` endpoint.

package/node_modules/@mininglamp-oss/octo-runtime-extra-channel-gateway/dist/transport/card-session.d.ts

@@ -1,6 +1,6 @@
 /**
  * 单 Run 卡片会话：首次创建、后续编辑同一消息，并用序号和终态屏障收敛状态。
- * 卡片失败独立记录，最终文本仍由执行编排投递；发送回执不代表客户端已经渲染。
+ * 终态卡片失败由 finish 返回，最终文本仍由执行编排投递；回执不代表客户端已经渲染。
  */
 import type { ImAddress } from "../contracts.js";
 import type { OctoConnector } from "./connector.js";

package/node_modules/@mininglamp-oss/octo-runtime-extra-channel-gateway/dist/transport/card-session.js

@@ -10,6 +10,7 @@ export class CardSession {
     onDiagnostic;
     #messageId;
     #seq = 0;
+    #terminalFailed = false;
     #scheduler;
     effectKey;
     constructor(connector, delivery, address, runId, stopTyping, onDiagnostic) {
@@ -19,7 +20,16 @@ export class CardSession {
         this.stopTyping = stopTyping;
         this.onDiagnostic = onDiagnostic;
         this.effectKey = stableEffectKey(imBotIdentity(connector.config), address, runId, "progress");
-        this.#scheduler = new ProgressScheduler((snapshot) => this.#send(snapshot), () => onDiagnostic("IM_CARD_FAILED"));
+        this.#scheduler = new ProgressScheduler(async (snapshot) => {
+            try {
+                await this.#send(snapshot);
+            }
+            catch (error) {
+                if (snapshot.terminal || snapshot.resultUnknown)
+                    this.#terminalFailed = true;
+                throw error;
+            }
+        }, () => onDiagnostic("IM_CARD_FAILED"));
     }
     update(snapshot) {
         if (snapshot.terminal || snapshot.phase === "waiting")
@@ -27,17 +37,21 @@ export class CardSession {
         this.#scheduler.enqueue(snapshot, !!snapshot.terminal || !!snapshot.resultUnknown);
     }
     async #send(snapshot) {
+        const settled = !!snapshot.terminal || !!snapshot.resultUnknown;
         const template = await this.connector.reasoningTemplate();
         if (!template) {
+            if (settled && this.#messageId)
+                this.#terminalFailed = true;
             this.onDiagnostic("IM_CARD_UNAVAILABLE");
             return;
         }
         const frame = buildReasoningFrame(snapshot, template);
         if (!frame) {
+            if (settled)
+                this.#terminalFailed = true;
             this.onDiagnostic("IM_CARD_BUDGET_EXCEEDED");
             return;
         }
-        const settled = !!snapshot.terminal || !!snapshot.resultUnknown;
         // 模板查询期间可能已收到终态；旧快照必须在出站前再次检查。
         if (this.#scheduler.terminal && !settled)
             return;
@@ -48,12 +62,17 @@ export class CardSession {
             this.#messageId = receipt.messageId;
             this.stopTyping();
         }
-        else
+        else {
+            if (settled)
+                this.#terminalFailed = true;
             this.onDiagnostic(receipt.code ?? "IM_CARD_FAILED");
+        }
     }
     async finish() {
         this.stopTyping();
         await this.#scheduler.flush();
+        if (this.#terminalFailed)
+            throw new Error("IM_CARD_FINALIZATION_FAILED");
     }
     get messageId() {
         return this.#messageId;

package/node_modules/@mininglamp-oss/octo-runtime-extra-channel-gateway/dist/transport/channel.d.ts

@@ -36,7 +36,7 @@ export declare class GatewayTransport {
     constructor(config: OctoBotConfig, credentials: ImCredentialSource, callbacks: ChannelCallbacks);
     get status(): {
         connected: boolean;
-        cardDeliveries: import("../contracts.js").ImDeliveryReceipt[];
+        cardDeliveries: number;
     };
     start(signal: AbortSignal): Promise<void>;
     close(): Promise<void>;

package/node_modules/@mininglamp-oss/octo-runtime-extra-channel-gateway/dist/transport/channel.js

@@ -7,7 +7,7 @@ import { interactionCard, interactionAnswer } from "./interaction-card.js";
 import { imBotIdentity } from "../lifecycle/configuration.js";
 import { verifyBotIdentity } from "./auth.js";
 import { registerBot, WukongConnection } from "./wukong.js";
-import { acceptsImMessage, groupScope } from "./normalize.js";
+import { acceptsImMessage, groupScope, isRulesNotification, rulesChange } from "./normalize.js";
 import { build_im_contexts } from "./contexts.js";
 import { OctoConnector, stableEffectKey } from "./connector.js";
 import { CardSession } from "./card-session.js";
@@ -27,6 +27,7 @@ import { connectionFailure, ImConnectionError } from "./connection-error.js";
 import { sendReadReceipt } from "./api/messages.js";
 import { deliveryNoticeCard } from "../presentation/delivery-notice.js";
 import { ImSendError } from "../delivery/text-send.js";
+import { observesImScope } from "./normalize.js";
 /** Octo IM 平台连接器：WuKong 与 Octo REST 适配；不是 MCP 连接器。 */
 export class GatewayTransport {
     config;
@@ -57,7 +58,10 @@ export class GatewayTransport {
         this.botId = config.bot_id;
     }
     get status() {
-        return { connected: this.#connected, cardDeliveries: this.#delivery?.receipts ?? [] };
+        return {
+            connected: this.#connected,
+            cardDeliveries: this.#delivery?.receiptCount ?? 0
+        };
     }
     async start(signal) {
         this.#closed = false;
@@ -80,11 +84,46 @@ export class GatewayTransport {
         if (registration.robot_id !== this.config.bot_id)
             throw new Error("IM_BOT_IDENTITY_MISMATCH");
         const connection = new WukongConnection((message) => {
-            if (this.#closed || !acceptsImMessage(this.scopedConfig, registration.owner_uid, message))
+            if (this.#closed)
+                return;
+            // 服务端规则通知即使 @ 全部 Bot，也只失效上下文，不能进入任务/卡片路径。
+            if (isRulesNotification(message)) {
+                const change = rulesChange(message);
+                if (change &&
+                    observesImScope(this.scopedConfig, message.channelId, message.channelType, message.payload.space_id))
+                    this.callbacks.onRulesChanged?.(change);
+                return;
+            }
+            if (!acceptsImMessage(this.scopedConfig, registration.owner_uid, message))
                 return;
             let finalReply;
+            let historyTurn;
+            const outputObserver = () => {
+                const turn = historyTurn;
+                if (!turn || !observesImScope(this.scopedConfig, message.channelId, message.channelType))
+                    return undefined;
+                return (messageSeq) => {
+                    if (this.#closed || signal.aborted)
+                        return;
+                    this.callbacks.onPosition?.({
+                        conversationId: message.channelId,
+                        conversationKind: message.channelType === 5 ? "thread" : "group",
+                        messageSeq,
+                        own: true,
+                        turn
+                    });
+                };
+            };
             this.callbacks.onMessage({
                 messageId: message.messageId,
+                ...(message.channelType === 2 || message.channelType === 5
+                    ? {
+                        position: { messageSeq: message.messageSeq },
+                        bindHistoryTurn: (turn) => {
+                            historyTurn = structuredClone(turn);
+                        }
+                    }
+                    : {}),
                 markRead: (turnSignal) => sendReadReceipt({
                     apiUrl: this.config.api_url,
                     botToken: token,
@@ -150,7 +189,7 @@ export class GatewayTransport {
                     if (this.#closed || signal.aborted)
                         throw new Error("IM_CONNECTION_REPLACED");
                     const key = stableEffectKey(this.identity, message, effectKey ?? message.messageId, "text");
-                    await connection.sendText(message.channelId, message.channelType, text, key, this.#spaceId);
+                    await connection.sendText(message.channelId, message.channelType, text, key, this.#spaceId, undefined, undefined, outputObserver());
                 },
                 replyFinal: async (text, effectKey) => {
                     if (this.#closed || signal.aborted)
@@ -173,7 +212,7 @@ export class GatewayTransport {
                     const result = await finalReply.value;
                     if (this.#closed || signal.aborted)
                         throw new Error("IM_CONNECTION_REPLACED");
-                    await connection.sendText(message.channelId, message.channelType, result.text, stableEffectKey(this.identity, message, effectKey, "text"), this.#spaceId, result.mention);
+                    await connection.sendText(message.channelId, message.channelType, result.text, stableEffectKey(this.identity, message, effectKey, "text"), this.#spaceId, result.mention, undefined, outputObserver());
                 },
                 buildContext: async (turnSignal, options) => ({
                     schema: CONTEXT_SCHEMA,
@@ -185,8 +224,11 @@ export class GatewayTransport {
                         const entry = interactions.get(id);
                         if (!entry)
                             return;
+                        const messageId = await this.#api.interactionCard(message, interactionCard(entry.request, status), stableEffectKey(this.identity, message, id, "interaction"), entry.messageId);
+                        // 能力不可用会返回 undefined；已显示卡片只有确认编辑成功后才能移除。
+                        if (messageId !== entry.messageId)
+                            throw new Error("IM_INTERACTION_CARD_FINALIZATION_UNCONFIRMED");
                         interactions.delete(id);
-                        await this.#api.interactionCard(message, interactionCard(entry.request, status), stableEffectKey(this.identity, message, id, "interaction"), entry.messageId);
                     };
                     const stopTyping = this.config.typing === false ? () => { } : this.#typing.acquire(message, runId);
                     const card = new CardSession(this.#api, this.#delivery, message, runId, stopTyping, onDiagnostic);
@@ -197,6 +239,7 @@ export class GatewayTransport {
                         controls,
                         expires: Date.now() + 86_400_000 + 30 * 60_000,
                         active: true,
+                        turn: historyTurn,
                         interactions
                     });
                     if (this.#bindings.size > 128) {
@@ -228,16 +271,25 @@ export class GatewayTransport {
                         resolveInteraction,
                         update: (snapshot) => card.update(snapshot),
                         finish: async () => {
+                            const errors = [];
                             try {
                                 for (const id of interactions.keys()) {
                                     try {
                                         await resolveInteraction(id, "invalidated");
                                     }
-                                    catch {
+                                    catch (error) {
+                                        errors.push(error);
                                         onDiagnostic("IM_INTERACTION_CARD_FAILED");
                                     }
                                 }
-                                await card.finish();
+                                try {
+                                    await card.finish();
+                                }
+                                catch (error) {
+                                    errors.push(error);
+                                }
+                                if (errors.length)
+                                    throw new AggregateError(errors, "IM_PRESENTATION_FAILED");
                             }
                             finally {
                                 const binding = this.#bindings.get(runId);
@@ -254,6 +306,26 @@ export class GatewayTransport {
             this.#connected = false;
             const failure = connectionFailure(error);
             this.callbacks.onDisconnect(failure.message, failure.retryable);
+        }, (position) => {
+            if (this.#closed ||
+                signal.aborted ||
+                !observesImScope(this.scopedConfig, position.channelId, position.channelType, position.spaceId))
+                return;
+            const own = position.fromUid === this.config.bot_id;
+            const binding = own
+                ? [...this.#bindings.values()].find((candidate) => candidate.address.channelId === position.channelId &&
+                    candidate.address.channelType === position.channelType &&
+                    (candidate.card.effectKey === position.clientMsgNo ||
+                        candidate.card.messageId === position.messageId ||
+                        [...candidate.interactions.values()].some((entry) => entry.messageId === position.messageId)))
+                : undefined;
+            this.callbacks.onPosition?.({
+                conversationId: position.channelId,
+                conversationKind: position.channelType === 5 ? "thread" : "group",
+                messageSeq: position.messageSeq,
+                own,
+                ...(binding?.turn ? { turn: binding.turn } : {})
+            });
         });
         this.#connection = connection;
         this.#api = new OctoConnector(this.config, token, signal, async (address, text, effectKey) => {

package/node_modules/@mininglamp-oss/octo-runtime-extra-channel-gateway/dist/transport/contexts.d.ts

@@ -1,13 +1,16 @@
 /**
- * IM 业务输入：规则按轮读取；新会话仅尝试一次历史，资格由调用方的有界会话管理。
+ * IM 业务输入：规则与有界历史在模型执行前通过API读取，重试复用冻结快照。
  */
 import { type ContextItem } from "@mininglamp-oss/octo-runtime-protocol";
 import type { ScopedOctoBotConfig } from "../contracts.js";
 import type { ImMessage } from "./wukong.js";
+import { type ImGapPlan } from "../application/context-gap.js";
 export declare function build_im_contexts(config: ScopedOctoBotConfig, message: ImMessage, botToken: string, signal: AbortSignal, options?: {
     initialSession: boolean;
     mentionGuidance?: boolean;
     configuredItems?: readonly ContextItem[];
+    historyGap?: ImGapPlan;
+    onHistoryGapPrepared?(plan: ImGapPlan): void;
 }): Promise<ContextItem[]>;
 export declare function historyText(entries: Array<{
     from_uid: string;