@gestaltrun/dsh-im-runtime 0.1.0 → 0.1.6

package/lib/read-receipts.js

@@ -0,0 +1,413 @@
+import { a as senderUid, c as encodeImScopeId, i as sameBuyer, n as buyerReadState, r as buyerUid, t as buyerReadQuery, u as imDeliveryScopeSchema } from "./read-state-CnUZKCuY.js";
+import { brandString } from "@deepseek-ai/dsh-brand";
+import { SessionId } from "@deepseek-ai/dsh-session";
+import { defineDomain, domainTable } from "@deepseek-ai/dsh-storage-domain";
+import { z } from "zod";
+import { createUserMessage } from "@deepseek-ai/dsh-llm";
+//#region src/read-records.ts
+/** Independent durable read evidence; no tokens, raw SDK payloads or message bodies. */
+const association = z.object({
+	requestId: z.string().min(1).transform((value) => brandString(value)),
+	platformMessageId: z.string().min(1),
+	sdkConversationId: z.string().min(1),
+	buyerUid: z.string().min(1),
+	singleton: z.boolean(),
+	queried: z.boolean(),
+	state: z.enum([
+		"unknown",
+		"unread",
+		"read"
+	]),
+	observedAt: z.iso.datetime(),
+	sessionId: z.string().transform(SessionId).optional()
+});
+/** Product-owned read records; opening older IM configuration requires no migration. */
+const imReadsDomainSpec = defineDomain({
+	name: "gestaltrun_im_reads",
+	version: 1,
+	tables: { scopes: domainTable(z.object({
+		schema: z.literal("gestaltrun.im-reads.v1"),
+		scope: imDeliveryScopeSchema.refine((value) => value.kind === "real" && value.platform === "wangwang" && value.conversationKind === "direct"),
+		reported: z.record(z.string(), z.literal(true)),
+		outbounds: z.record(z.string(), association)
+	})) }
+});
+//#endregion
+//#region src/read-context.ts
+function recorded(session, scope, requestId) {
+	const scopeId = encodeImScopeId(scope);
+	return session.snapshotEvents().some((event) => event.type === "im/message-read" && event.data.requestId === requestId && encodeImScopeId(event.data.scope) === scopeId);
+}
+function append(session, scope, row) {
+	if (recorded(session, scope, row.requestId)) return false;
+	const data = {
+		scope,
+		requestId: row.requestId,
+		platformMessageId: brandString(row.platformMessageId),
+		observedAt: row.observedAt
+	};
+	session.append("im/message-read", data);
+	return true;
+}
+/** @param ctx - optional live Agent and persistence services. @param scope - verified outbound scope. @param row - confirmed buyer evidence. @returns after a live Session fact is durable; absent Agents receive it at their next pre-step. */
+async function recordLiveRead(ctx, scope, row) {
+	if (row.sessionId === void 0) return;
+	const agent = ctx.get("agents")?.get(row.sessionId);
+	const sessions = ctx.get("sessions");
+	if (agent !== void 0 && sessions !== void 0) {
+		append(agent.session, scope, row);
+		await sessions.flush(agent.session);
+	}
+}
+/** @param session - recorded facts and previously admitted contexts. @param proposed - contexts already proposed for this step. @returns each previously unannounced read once; source facts reconstruct the notification after a restart. */
+function readContextMessages(session, proposed = []) {
+	const sent = /* @__PURE__ */ new Set();
+	const key = (scopeId, requestId) => `${scopeId}:${requestId}`;
+	const remember = (message) => {
+		if (message.source.kind === "im-read") sent.add(key(message.source.scopeId, message.source.requestId));
+	};
+	for (const event of session.snapshotEvents()) if (event.type === "user/message") remember(event.data);
+	for (const message of proposed) remember(message);
+	const messages = [];
+	for (const event of session.snapshotEvents()) {
+		if (event.type !== "im/message-read") continue;
+		const scopeId = encodeImScopeId(event.data.scope);
+		const id = key(scopeId, event.data.requestId);
+		if (sent.has(id)) continue;
+		sent.add(id);
+		const text = `The buyer has read outbound message ${event.data.requestId}. This receipt confirms reading; it does not confirm agreement or satisfaction.`;
+		messages.push(createUserMessage({
+			content: [{
+				type: "text",
+				text
+			}],
+			source: {
+				kind: "im-read",
+				scopeId,
+				requestId: event.data.requestId,
+				form: "notice",
+				summary: "Buyer read the message"
+			}
+		}));
+	}
+	return messages;
+}
+/** @param ctx - registration owner. @param table - independent durable read evidence. @returns exact child disposer, joined before the table closes. Context reconstruction does not wake idle Agents. */
+function installReadContext(ctx, table) {
+	return ctx.inject(["agents", "sessions"], (child) => {
+		child.effect(() => child.on("agent/pre-step", async ({ agent }, next) => {
+			const decision = await next();
+			if (decision.kind === "reject") return decision;
+			let changed = false;
+			for (const [, record] of table.entries()) for (const row of Object.values(record.outbounds)) if (row.state === "read" && row.sessionId === agent.id) changed = append(agent.session, record.scope, row) || changed;
+			const contexts = readContextMessages(agent.session, decision.messages);
+			if (changed || contexts.length > 0) await child.sessions.flush(agent.session);
+			return {
+				...decision,
+				messages: [...decision.messages, ...contexts]
+			};
+		}));
+	}).dispose;
+}
+//#endregion
+//#region src/read-receipts.ts
+const configSchema = z.object({ pendingMessageLimit: z.number().int().positive().max(1e5).default(1e3) }).strict();
+const messageSchema = z.object({ message: z.object({
+	messageId: z.string().min(1),
+	cid: z.string().min(1).optional(),
+	appCid: z.string().min(1).optional(),
+	uuid: z.string().optional(),
+	sender: z.union([z.string(), z.object({ uid: z.string() })]),
+	receivers: z.array(z.string()).optional()
+}) });
+var ReadOwner = class {
+	ctx;
+	sdk;
+	table;
+	limit;
+	pending = /* @__PURE__ */ new Map();
+	queried = /* @__PURE__ */ new Map();
+	observers = /* @__PURE__ */ new Set();
+	chain = Promise.resolve();
+	closed = false;
+	constructor(ctx, sdk, table, limit) {
+		this.ctx = ctx;
+		this.sdk = sdk;
+		this.table = table;
+		this.limit = limit;
+	}
+	snapshot(scope) {
+		const key = encodeImScopeId(scope);
+		const status = this.sdk.status(scope.accountId);
+		return Object.values(this.table.get(key)?.outbounds ?? {}).flatMap((row) => row.state === "unknown" || row.state === "unread" && (status.state !== "online" || this.queried.get(`${key}:${row.requestId}`) !== status.generation) ? [] : [{
+			requestId: row.requestId,
+			state: row.state
+		}]);
+	}
+	subscribe(listener) {
+		this.observers.add(listener);
+		return () => {
+			this.observers.delete(listener);
+		};
+	}
+	submit(event, availabilityChanged = false) {
+		if (this.closed) return Promise.resolve();
+		const task = this.chain.then(async () => {
+			if (this.closed) return;
+			if (event !== void 0) await this.accept(event);
+			else for (const pending of [...this.pending.values()]) await this.correlate(pending);
+			if (availabilityChanged) for (const [, stored] of this.table.entries()) this.publish(stored.scope);
+		});
+		this.chain = task.catch(() => {
+			this.ctx.logger.warn("IM_READ_SYNC_FAILED: read evidence remains unknown; no automatic retry");
+		});
+		return this.chain;
+	}
+	current(event) {
+		const status = this.sdk.status(event.accountId);
+		return status.state === "online" && status.generation === event.generation;
+	}
+	async accept(event) {
+		if (!this.current(event)) return;
+		if (event.kind === "message") {
+			const parsed = messageSchema.safeParse(event.data);
+			if (!parsed.success || parsed.data.message.cid === void 0 && parsed.data.message.appCid === void 0) return;
+			await this.observe({
+				event,
+				source: "message",
+				message: parsed.data.message
+			});
+		} else if (event.kind === "receipt") {
+			const parsed = z.object({
+				messageId: z.string().min(1),
+				requestId: z.string().min(1),
+				conversationId: z.string().min(1)
+			}).safeParse(event.data);
+			if (!parsed.success) return;
+			await this.observe({
+				event,
+				source: "receipt",
+				message: {
+					messageId: parsed.data.messageId,
+					uuid: parsed.data.requestId,
+					cid: parsed.data.conversationId
+				}
+			});
+		} else if (event.kind === "read-to-sender") {
+			const values = Array.isArray(event.data.events) ? event.data.events : [event.data];
+			for (const value of values) {
+				const parsed = z.object({
+					cid: z.string(),
+					conversationType: z.literal(1),
+					messageId: z.string(),
+					receiverCount: z.number().int().nonnegative().optional(),
+					unreadCount: z.number().int().nonnegative().optional()
+				}).safeParse(value);
+				if (!parsed.success) continue;
+				await this.observe({
+					event,
+					source: "read-to-sender",
+					message: {
+						messageId: parsed.data.messageId,
+						cid: parsed.data.cid
+					}
+				});
+				for (const [key, stored] of this.table.entries()) {
+					if (stored.scope.accountId !== event.accountId) continue;
+					for (const row of Object.values(stored.outbounds)) if (row.platformMessageId === parsed.data.messageId && row.sdkConversationId === parsed.data.cid && row.state !== "read") {
+						const state = buyerReadState(parsed.data, row.singleton);
+						if (state !== "unknown") {
+							this.queried.set(`${key}:${row.requestId}`, event.generation);
+							await this.save(key, stored.scope, {
+								...row,
+								state,
+								observedAt: (/* @__PURE__ */ new Date()).toISOString()
+							});
+						} else if (parsed.data.receiverCount !== void 0 && parsed.data.unreadCount !== void 0) {
+							const next = await this.query(event, key, stored.scope, row, "push");
+							await this.save(key, stored.scope, next);
+						}
+					}
+				}
+			}
+		}
+	}
+	async observe(observed) {
+		const { event, message } = observed;
+		const key = `${event.accountId}:${event.generation}:${message.messageId}`;
+		if (!this.pending.has(key) && this.pending.size >= this.limit) {
+			const oldest = this.pending.keys().next().value;
+			if (oldest !== void 0) this.pending.delete(oldest);
+			this.ctx.logger.warn("IM_READ_PENDING_FULL: oldest unmatched observation discarded; its receipt remains unknown");
+		}
+		this.pending.set(key, observed);
+		await this.correlate(observed);
+	}
+	async correlate({ event, message, source }) {
+		if (!this.current(event)) {
+			this.remove(event, message.messageId);
+			return;
+		}
+		const matches = this.ctx.imRuntime.matchSdkMessage(event.accountId, message.messageId, message.uuid);
+		if (matches.length !== 1) return;
+		const match = matches[0];
+		const buyer = buyerUid(match.buyer);
+		const sender = senderUid(message.sender);
+		const cid = message.cid ?? message.appCid;
+		const key = encodeImScopeId(match.scope);
+		const stored = this.table.get(key) ?? {
+			schema: "gestaltrun.im-reads.v1",
+			scope: match.scope,
+			reported: {},
+			outbounds: {}
+		};
+		if (match.inbound !== void 0) {
+			if (source !== "message" || sender === void 0 || !sameBuyer(sender, buyer) || match.inbound.sender.kind !== "external" || match.inbound.sender.senderId !== match.buyer.providerActorId) return;
+			if (stored.reported[message.messageId] !== void 0) {
+				this.remove(event, message.messageId);
+				return;
+			}
+			await this.table.put(key, {
+				...stored,
+				reported: {
+					...stored.reported,
+					[message.messageId]: true
+				}
+			});
+			if (!this.current(event)) return;
+			this.remove(event, message.messageId);
+			try {
+				await this.sdk.withConnection(event.accountId, event.generation, (lease) => lease.markRead(brandString(cid), [brandString(message.messageId)]));
+			} catch (error) {
+				this.ctx.logger.warn("IM_READ_REPORT_FAILED: buyer read acknowledgement unconfirmed; no automatic retry");
+			}
+			return;
+		}
+		const outbound = match.outbound;
+		const account = this.ctx.imRuntime.snapshot().accounts.find((value) => value.id === event.accountId);
+		if (outbound === void 0 || account?.identity.platform !== "wangwang") return;
+		const previous = stored.outbounds[outbound.requestId];
+		if (previous !== void 0 && (previous.platformMessageId !== message.messageId || previous.buyerUid !== buyer || previous.sdkConversationId !== cid)) return;
+		if (source === "message") {
+			if (sender === void 0 || account.identity.mainServiceAccountId === void 0 || !sameBuyer(sender, account.identity.mainServiceAccountId)) return;
+		} else {
+			if (outbound.externalMessageId !== message.messageId) return;
+			try {
+				const resolved = previous?.sdkConversationId ?? await this.sdk.withConnection(event.accountId, event.generation, (lease) => lease.resolveConversation(brandString(buyer)));
+				if (!this.current(event) || resolved !== cid) {
+					this.remove(event, message.messageId);
+					return;
+				}
+			} catch (error) {
+				this.remove(event, message.messageId);
+				this.ctx.logger.warn("IM_READ_CONVERSATION_FAILED: read association unconfirmed; no automatic retry");
+				return;
+			}
+		}
+		const task = this.ctx.imRuntime.getAgentTask(match.scope);
+		const sessionId = outbound.manualBinding?.sessionId ?? (task !== void 0 && task.createdAt <= outbound.createdAt ? task.sessionId : void 0);
+		let row = previous ?? {
+			requestId: outbound.requestId,
+			platformMessageId: message.messageId,
+			sdkConversationId: cid,
+			buyerUid: buyer,
+			singleton: message.receivers?.length === 1 && sameBuyer(message.receivers[0], buyer),
+			queried: false,
+			state: "unknown",
+			observedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			...sessionId === void 0 ? {} : { sessionId }
+		};
+		this.remove(event, message.messageId);
+		row = await this.query(event, key, match.scope, row, "association");
+		await this.save(key, match.scope, row);
+	}
+	async query(event, key, scope, row, phase) {
+		const queryKey = phase === "association" ? `${key}:${row.requestId}` : `${key}:${row.requestId}:push`;
+		if (row.state === "read" || this.queried.get(queryKey) === event.generation) return row;
+		this.queried.set(queryKey, event.generation);
+		let next = {
+			...row,
+			queried: true,
+			state: "unknown"
+		};
+		await this.save(key, scope, next);
+		if (!this.current(event)) return next;
+		try {
+			const result = await this.sdk.withConnection(event.accountId, event.generation, (lease) => lease.queryRead(brandString(row.sdkConversationId), brandString(row.platformMessageId)));
+			if (!this.current(event)) return next;
+			const parsed = buyerReadQuery(result, row.buyerUid);
+			next = {
+				...next,
+				singleton: row.singleton || parsed.singleton,
+				state: parsed.state,
+				observedAt: (/* @__PURE__ */ new Date()).toISOString()
+			};
+			this.queried.set(`${key}:${row.requestId}`, event.generation);
+		} catch (error) {
+			this.ctx.logger.warn("IM_BUYER_READ_QUERY_FAILED: buyer state remains unknown; no automatic retry");
+		}
+		return next;
+	}
+	publish(scope) {
+		for (const observer of this.observers) try {
+			observer(scope);
+		} catch (error) {
+			this.observers.delete(observer);
+			this.ctx.logger.warn("IM_READ_OBSERVER_FAILED: subscription withdrawn");
+		}
+	}
+	remove(event, id) {
+		this.pending.delete(`${event.accountId}:${event.generation}:${id}`);
+	}
+	async save(key, scope, row) {
+		const current = this.table.get(key) ?? {
+			schema: "gestaltrun.im-reads.v1",
+			scope,
+			reported: {},
+			outbounds: {}
+		};
+		await this.table.put(key, {
+			...current,
+			outbounds: {
+				...current.outbounds,
+				[row.requestId]: row
+			}
+		});
+		this.publish(scope);
+		if (row.state === "read") await recordLiveRead(this.ctx, scope, row);
+	}
+	async dispose() {
+		this.closed = true;
+		await this.chain;
+		this.pending.clear();
+		this.queried.clear();
+		this.observers.clear();
+	}
+};
+/** Host services required before opening independent read storage. */
+const inject = ["imRuntime", "storageDomain"];
+/** @param ctx - durable runtime and storage owner. @param config - bounded unmatched-message admission. @returns after the read domain and optional SDK consumers are installed. */
+async function apply(ctx, config = {}) {
+	const spec = configSchema.parse(config);
+	const domain = await ctx.storageDomain.open(imReadsDomainSpec);
+	ctx.effect(function* () {
+		yield ctx.effect(() => () => domain.close(), "imReads: domain");
+		yield installReadContext(ctx, domain.table("scopes"));
+		yield ctx.inject(["imSdk"], (child) => {
+			const owner = new ReadOwner(child, child.imSdk, domain.table("scopes"), spec.pendingMessageLimit);
+			child.effect(function* () {
+				yield child.effect(() => () => owner.dispose(), "imReads: joined work");
+				yield child.provide("imReads", owner);
+				yield child.imSdk.subscribeEvents((event) => owner.submit(event));
+				yield child.imRuntime.subscribeDelivery(() => {
+					owner.submit();
+				});
+				yield child.imSdk.subscribe(() => {
+					owner.submit(void 0, true);
+				});
+			});
+		}).dispose;
+	});
+}
+//#endregion
+export { apply, inject };