doover-js 0.11.0 → 0.13.0

package/dist/esm/client/offline-cache.js

@@ -0,0 +1,769 @@
+import { browserNetworkStatus } from "./network-status.js";
+import { DooverOfflineError } from "./errors.js";
+import { delegateRequestOptions, splitRequestOptions, } from "./request-options.js";
+export const DEFAULT_OFFLINE_RETENTION_MS = 7 * 24 * 60 * 60 * 1000;
+export class MemoryOfflineStorageAdapter {
+    constructor() {
+        this.json = new Map();
+        this.blobs = new Map();
+    }
+    async getJson(key) {
+        return this.json.get(key);
+    }
+    async setJson(key, record) {
+        this.json.set(key, record);
+    }
+    async deleteJson(key) {
+        this.json.delete(key);
+    }
+    async listJsonKeys(prefix) {
+        const keys = [...this.json.keys()];
+        return prefix ? keys.filter((key) => key.startsWith(prefix)) : keys;
+    }
+    async clearScope(scope) {
+        for (const [key, record] of this.json) {
+            if (scopeMatches(record.scope, scope))
+                this.json.delete(key);
+        }
+        for (const [key, record] of this.blobs) {
+            if (scopeMatches(record.metadata.scope, scope))
+                this.blobs.delete(key);
+        }
+    }
+    async getBlob(key) {
+        return this.blobs.get(key)?.blob;
+    }
+    async setBlob(key, blob, metadata) {
+        this.blobs.set(key, { blob, metadata });
+    }
+    async deleteBlob(key) {
+        this.blobs.delete(key);
+    }
+}
+const SCHEMA_VERSION = 1;
+const INITIAL_OFFLINE_STATUS = {
+    online: true,
+    state: "online",
+    isOfflineFallback: false,
+    isExpired: false,
+    at: 0,
+};
+export class OfflineDataClient {
+    constructor(options) {
+        this.offlineStatusListeners = new Set();
+        this.offlineStatus = INITIAL_OFFLINE_STATUS;
+        this.persistQueue = Promise.resolve();
+        this.client = options.client;
+        this.networkStatus = options.networkStatus ?? options.client.networkStatus ?? browserNetworkStatus;
+        this.storage = options.storage;
+        this.scope = options.scope;
+        this.defaultRetentionMs = options.defaultRetentionMs ?? DEFAULT_OFFLINE_RETENTION_MS;
+        this.isOnlineFn = options.isOnline;
+        this.policies = [...(options.policies ?? [])];
+        this.agents = this.makeAgentsFacade();
+        this.channels = this.makeChannelsFacade();
+        this.messages = this.makeMessagesFacade();
+        this.aggregates = this.makeAggregatesFacade();
+        this.alarms = this.passThroughSubclient("alarms");
+        this.connections = this.passThroughSubclient("connections");
+        this.notifications = this.passThroughSubclient("notifications");
+        this.permissions = this.passThroughSubclient("permissions");
+        this.processors = this.passThroughSubclient("processors");
+        this.turn = this.passThroughSubclient("turn");
+        this.users = this.passThroughSubclient("users");
+        this.gateway = this.makeGatewayFacade();
+        this.rpc = this.makeRpcFacade();
+    }
+    setChannelPolicy(policy) {
+        const id = policy.id ?? `${policy.channel.agentId ?? "*"}/${policy.channel.channelName}`;
+        this.policies = [
+            ...this.policies.filter((existing) => (existing.id ?? `${existing.channel.agentId ?? "*"}/${existing.channel.channelName}`) !== id),
+            { ...policy, id },
+        ];
+    }
+    setChannelPolicies(policies) {
+        this.policies = [...policies];
+    }
+    getChannelPolicies() {
+        return this.policies;
+    }
+    getOfflineStatus() {
+        const online = this.isOnline();
+        if (online !== this.offlineStatus.online) {
+            this.offlineStatus = { ...this.offlineStatus, online, at: Date.now() };
+        }
+        return this.offlineStatus;
+    }
+    onOfflineStatusChange(listener) {
+        this.offlineStatusListeners.add(listener);
+        if (!this.unsubscribeNetwork) {
+            this.unsubscribeNetwork = this.networkStatus.subscribe(() => {
+                const status = this.getOfflineStatus();
+                this.offlineStatusListeners.forEach((callback) => callback(status));
+            });
+        }
+        let active = true;
+        return () => {
+            if (!active)
+                return;
+            active = false;
+            this.offlineStatusListeners.delete(listener);
+            if (!this.offlineStatusListeners.size) {
+                this.unsubscribeNetwork?.();
+                this.unsubscribeNetwork = undefined;
+            }
+        };
+    }
+    async clearScope(scope = this.scope) {
+        if (this.storage.clearScope) {
+            await this.storage.clearScope(scope);
+            return;
+        }
+        const keys = await this.storage.listJsonKeys?.(this.scopePrefix(scope));
+        if (!keys || !this.storage.deleteJson)
+            return;
+        await Promise.all(keys.map((key) => this.storage.deleteJson(key)));
+    }
+    getCapabilities() { return this.client.getCapabilities(); }
+    supports(cap) { return this.client.supports(cap); }
+    isConnected() { return this.client.isConnected(); }
+    getStatus() { return this.client.getStatus(); }
+    onStatusChange(listener) {
+        return this.client.onStatusChange(listener);
+    }
+    getAgentScope() { return this.client.getAgentScope(); }
+    getKnownAgentScope() { return this.client.getKnownAgentScope(); }
+    makeAgentsFacade() {
+        const target = this.client.agents;
+        return {
+            listAgents: ((...rawArgs) => {
+                const { args, request } = splitRequestOptions(rawArgs);
+                return this.readCached(() => target.listAgents(...this.withDelegateOptions(args, request)), {
+                    operation: "agents.listAgents",
+                    kind: "agents.list",
+                    keyParts: ["agents", "list", args],
+                    request,
+                });
+            }),
+            getMultiAgentMessages: ((channelName, ...rest) => {
+                const { args, request } = splitRequestOptions([channelName, ...rest]);
+                const params = args[1];
+                return this.readCached(() => target.getMultiAgentMessages(...this.withDelegateOptions(args, request)), {
+                    operation: "agents.getMultiAgentMessages",
+                    kind: "agents.multiAgentMessages",
+                    keyParts: ["agents", "multiAgentMessages", args],
+                    channelName: String(args[0]),
+                    agentId: params?.agent_id?.join(","),
+                    request,
+                });
+            }),
+            getMultiAgentAggregates: ((channelName, ...rest) => {
+                const { args, request } = splitRequestOptions([channelName, ...rest]);
+                const params = args[1];
+                return this.readCached(() => target.getMultiAgentAggregates(...this.withDelegateOptions(args, request)), {
+                    operation: "agents.getMultiAgentAggregates",
+                    kind: "agents.multiAgentAggregates",
+                    keyParts: ["agents", "multiAgentAggregates", args],
+                    channelName: String(args[0]),
+                    agentId: params?.agent_id?.join(","),
+                    request,
+                });
+            }),
+        };
+    }
+    makeChannelsFacade() {
+        const target = this.client.channels;
+        return {
+            listChannels: ((...rawArgs) => {
+                const { args, request } = splitRequestOptions(rawArgs);
+                const agentId = extractAgentId(args);
+                return this.readCached(() => target.listChannels(...this.withDelegateOptions(args, request)), {
+                    operation: "channels.listChannels",
+                    kind: "channels.list",
+                    keyParts: ["channels", "list", args],
+                    agentId,
+                    request,
+                });
+            }),
+            getChannel: ((...rawArgs) => {
+                const { args, request } = splitRequestOptions(rawArgs);
+                const { agentId, channelName } = extractChannelId(args);
+                return this.readCached(() => target.getChannel(...this.withDelegateOptions(args, request)), {
+                    operation: "channels.getChannel",
+                    kind: "channels.get",
+                    keyParts: ["channels", "get", args],
+                    agentId,
+                    channelName,
+                    request,
+                });
+            }),
+            createChannel: this.offlineGuard("channels.createChannel", target.createChannel.bind(target)),
+            putChannel: this.offlineGuard("channels.putChannel", target.putChannel.bind(target)),
+            archiveChannel: this.offlineGuard("channels.archiveChannel", target.archiveChannel.bind(target)),
+            unarchiveChannel: this.offlineGuard("channels.unarchiveChannel", target.unarchiveChannel.bind(target)),
+            listDataSeries: ((...args) => target.listDataSeries(...args)),
+        };
+    }
+    makeAggregatesFacade() {
+        const target = this.client.aggregates;
+        return {
+            getAggregate: ((...rawArgs) => {
+                const { args, request } = splitRequestOptions(rawArgs);
+                const { agentId, channelName } = extractChannelId(args);
+                return this.readCached(() => target.getAggregate(...this.withDelegateOptions(args, request)), {
+                    operation: "aggregates.getAggregate",
+                    kind: "aggregates.get",
+                    keyParts: ["aggregates", "get", args],
+                    agentId,
+                    channelName,
+                    request,
+                    serverUpdatedAt: (value) => typeof value?.last_updated === "number"
+                        ? value.last_updated
+                        : undefined,
+                });
+            }),
+            putAggregate: this.offlineGuard("aggregates.putAggregate", target.putAggregate.bind(target)),
+            patchAggregate: this.offlineGuard("aggregates.patchAggregate", target.patchAggregate.bind(target)),
+            batchPatchAggregates: this.offlineGuard("aggregates.batchPatchAggregates", target.batchPatchAggregates.bind(target)),
+            getAggregateAttachment: ((...rawArgs) => {
+                const { args, request } = splitRequestOptions(rawArgs);
+                const { agentId, channelName } = extractChannelId(args);
+                const attachmentId = String(args[2] ?? args[1] ?? "");
+                return this.readBlobCached(() => target.getAggregateAttachment(...this.withDelegateOptions(args, request)), {
+                    operation: "aggregates.getAggregateAttachment",
+                    kind: "aggregates.attachment",
+                    keyParts: ["aggregates", "attachment", args, attachmentId],
+                    agentId,
+                    channelName,
+                    request,
+                });
+            }),
+        };
+    }
+    makeMessagesFacade() {
+        const target = this.client.messages;
+        return {
+            listMessages: ((...rawArgs) => {
+                const { args, request } = splitRequestOptions(rawArgs);
+                const { agentId, channelName } = extractChannelId(args);
+                return this.readCached(() => target.listMessages(...this.withDelegateOptions(args, request)), {
+                    operation: "messages.listMessages",
+                    kind: "messages.list",
+                    keyParts: ["messages", "list", args],
+                    fallbackKeyParts: this.latestMessagesKeyParts(agentId ?? "", channelName ?? ""),
+                    agentId,
+                    channelName,
+                    request,
+                    serverUpdatedAt: newestMessageTimestamp,
+                });
+            }),
+            getMessage: ((...rawArgs) => {
+                const { args, request } = splitRequestOptions(rawArgs);
+                const { agentId, channelName } = extractChannelId(args);
+                const messageId = String(args[2] ?? args[1] ?? "");
+                return this.readCached(() => target.getMessage(...this.withDelegateOptions(args, request)), {
+                    operation: "messages.getMessage",
+                    kind: "messages.get",
+                    keyParts: ["messages", "get", args, messageId],
+                    agentId,
+                    channelName,
+                    request,
+                    serverUpdatedAt: (value) => typeof value?.timestamp === "number"
+                        ? value.timestamp
+                        : undefined,
+                });
+            }),
+            postMessage: this.offlineGuard("messages.postMessage", target.postMessage.bind(target)),
+            putMessage: this.offlineGuard("messages.putMessage", target.putMessage.bind(target)),
+            patchMessage: this.offlineGuard("messages.patchMessage", target.patchMessage.bind(target)),
+            deleteMessage: this.offlineGuard("messages.deleteMessage", target.deleteMessage.bind(target)),
+            batchPostMessages: this.offlineGuard("messages.batchPostMessages", target.batchPostMessages.bind(target)),
+            batchPatchMessages: this.offlineGuard("messages.batchPatchMessages", target.batchPatchMessages.bind(target)),
+            batchPutMessages: this.offlineGuard("messages.batchPutMessages", target.batchPutMessages.bind(target)),
+            batchDeleteMessages: this.offlineGuard("messages.batchDeleteMessages", target.batchDeleteMessages.bind(target)),
+            getTimeseries: ((...args) => target.getTimeseries(...args)),
+            getMessageAttachment: ((...rawArgs) => {
+                const { args, request } = splitRequestOptions(rawArgs);
+                const { agentId, channelName } = extractChannelId(args);
+                const messageId = String(args[2] ?? args[1] ?? "");
+                const attachmentId = String(args[3] ?? args[2] ?? "");
+                return this.readBlobCached(() => target.getMessageAttachment(...this.withDelegateOptions(args, request)), {
+                    operation: "messages.getMessageAttachment",
+                    kind: "messages.attachment",
+                    keyParts: ["messages", "attachment", args, messageId, attachmentId],
+                    agentId,
+                    channelName,
+                    request,
+                });
+            }),
+            getInvocationLogs: ((...args) => target.getInvocationLogs(...args)),
+            createMultipartPayload: target.createMultipartPayload.bind(target),
+        };
+    }
+    makeGatewayFacade() {
+        const target = this.client.gateway;
+        return {
+            ...target,
+            connect: target.connect.bind(target),
+            disconnect: target.disconnect.bind(target),
+            on: target.on.bind(target),
+            off: target.off.bind(target),
+            subscribe: target.subscribe.bind(target),
+            unsubscribe: target.unsubscribe.bind(target),
+            subscribeToChannel: ((channel, handlers) => target.subscribeToChannel(channel, {
+                ...handlers,
+                onMessage: (message) => {
+                    this.enqueuePersist(() => this.persistGatewayMessage(message));
+                    handlers.onMessage?.(message);
+                },
+                onMessageUpdate: (message, requestData) => {
+                    this.enqueuePersist(() => this.persistGatewayMessage(message));
+                    handlers.onMessageUpdate?.(message, requestData);
+                },
+                onAggregate: (aggregate) => {
+                    this.enqueuePersist(() => this.persistGatewayAggregate(channel, aggregate));
+                    handlers.onAggregate?.(aggregate);
+                },
+            })),
+            syncChannel: this.offlineGuard("gateway.syncChannel", target.syncChannel.bind(target)),
+            sendOneShotMessage: this.offlineGuard("gateway.sendOneShotMessage", target.sendOneShotMessage.bind(target)),
+            getSession: target.getSession.bind(target),
+            isConnected: target.isConnected.bind(target),
+            getSubscriptionCount: target.getSubscriptionCount.bind(target),
+            getSubscriptions: target.getSubscriptions.bind(target),
+            reconnect: target.reconnect.bind(target),
+        };
+    }
+    makeRpcFacade() {
+        const target = this.client.rpc;
+        return {
+            setStats: target.setStats?.bind(target) ?? (() => undefined),
+            send: this.offlineGuard("rpc.send", target.send.bind(target)),
+        };
+    }
+    passThroughSubclient(name) {
+        const target = this.client[name];
+        return new Proxy({}, {
+            get: (_unused, prop) => {
+                if (typeof prop !== "string")
+                    return undefined;
+                const value = target[prop];
+                if (typeof value !== "function")
+                    return value;
+                const operation = `${name}.${prop}`;
+                if (isLikelyWrite(prop))
+                    return this.offlineGuard(operation, value.bind(target));
+                return value.bind(target);
+            },
+        });
+    }
+    offlineGuard(operation, fn) {
+        return ((...args) => {
+            if (!this.isOnline())
+                throw new DooverOfflineError(operation);
+            return fn(...args);
+        });
+    }
+    async readCached(fetcher, descriptor) {
+        const effective = this.effectivePolicy(descriptor);
+        const key = this.cacheKey(descriptor);
+        const fallbackKey = descriptor.fallbackKeyParts
+            ? this.cacheKey({ ...descriptor, kind: "messages.latest", keyParts: descriptor.fallbackKeyParts })
+            : undefined;
+        const read = () => this.readRecord(key, descriptor.operation, effective.allowExpired, fallbackKey);
+        if (effective.mode === "cache-only" || !this.isOnline()) {
+            return read();
+        }
+        if (effective.mode === "cache-first") {
+            const cached = await this.tryReadRecord(key, effective.allowExpired);
+            if (cached.hit)
+                return cached.value;
+        }
+        try {
+            const value = await fetcher();
+            if (effective.enabled) {
+                await this.writeRecord(key, descriptor, effective, value);
+                await this.writePolicyDerivedRecords(descriptor, effective, value);
+            }
+            this.setOfflineStatus({
+                state: "online",
+                operation: descriptor.operation,
+                cacheKey: key,
+                isOfflineFallback: false,
+                isExpired: false,
+            });
+            return value;
+        }
+        catch (error) {
+            if (!effective.enabled)
+                throw error;
+            const cached = await this.tryReadRecord(key, effective.allowExpired);
+            if (cached.hit)
+                return cached.value;
+            throw error;
+        }
+    }
+    async readBlobCached(fetcher, descriptor) {
+        const effective = this.effectivePolicy(descriptor);
+        const key = this.cacheKey(descriptor);
+        if (effective.mode === "cache-only" || !this.isOnline()) {
+            const cached = await this.storage.getBlob?.(key);
+            if (cached) {
+                this.setOfflineStatus({
+                    state: this.isOnline() ? "cache-hit" : "cache-fallback",
+                    operation: descriptor.operation,
+                    cacheKey: key,
+                    isOfflineFallback: !this.isOnline(),
+                    isExpired: false,
+                });
+                return cached;
+            }
+            this.setOfflineStatus({
+                state: "cache-miss",
+                operation: descriptor.operation,
+                cacheKey: key,
+                isOfflineFallback: !this.isOnline(),
+                isExpired: false,
+            });
+            throw new DooverOfflineError(descriptor.operation, `No cached attachment is available for "${descriptor.operation}" while offline.`, key);
+        }
+        if (effective.mode === "cache-first") {
+            const cached = await this.storage.getBlob?.(key);
+            if (cached)
+                return cached;
+        }
+        const value = await fetcher();
+        if (!(value instanceof Blob))
+            return value;
+        if (effective.enabled && this.shouldCacheAttachmentBlob(descriptor)) {
+            const now = Date.now();
+            await this.storage.setBlob?.(key, value, {
+                key,
+                scope: this.scope,
+                kind: descriptor.kind,
+                value: {
+                    content_type: value.type || null,
+                    size: value.size,
+                },
+                cachedAt: now,
+                lastAccessedAt: now,
+                expiresAt: effective.retentionMs > 0 ? now + effective.retentionMs : null,
+                schemaVersion: SCHEMA_VERSION,
+                ...(effective.policyId ? { policyId: effective.policyId } : {}),
+            });
+        }
+        this.setOfflineStatus({
+            state: "online",
+            operation: descriptor.operation,
+            cacheKey: key,
+            isOfflineFallback: false,
+            isExpired: false,
+        });
+        return value;
+    }
+    async readRecord(key, operation, allowExpired, fallbackKey) {
+        const result = await this.tryReadRecord(key, allowExpired);
+        if (result.hit)
+            return result.value;
+        if (fallbackKey) {
+            const fallback = await this.tryReadRecord(fallbackKey, allowExpired);
+            if (fallback.hit)
+                return fallback.value;
+        }
+        this.setOfflineStatus({
+            state: "cache-miss",
+            operation,
+            cacheKey: key,
+            isOfflineFallback: !this.isOnline(),
+            isExpired: false,
+        });
+        throw new DooverOfflineError(operation, `No cached data is available for "${operation}" while offline.`, key);
+    }
+    async tryReadRecord(key, allowExpired) {
+        const record = await this.storage.getJson(key);
+        if (!record)
+            return { hit: false };
+        const expired = record.expiresAt !== null && record.expiresAt <= Date.now();
+        if (expired && !allowExpired) {
+            this.setOfflineStatus({
+                state: "expired",
+                operation: record.kind,
+                cacheKey: key,
+                cachedAt: record.cachedAt,
+                expiresAt: record.expiresAt,
+                serverUpdatedAt: record.serverUpdatedAt ?? null,
+                isOfflineFallback: !this.isOnline(),
+                isExpired: true,
+            });
+            return { hit: false };
+        }
+        record.lastAccessedAt = Date.now();
+        await this.storage.setJson(key, record);
+        this.setOfflineStatus({
+            state: this.isOnline() ? "cache-hit" : "cache-fallback",
+            operation: record.kind,
+            cacheKey: key,
+            cachedAt: record.cachedAt,
+            expiresAt: record.expiresAt,
+            serverUpdatedAt: record.serverUpdatedAt ?? null,
+            isOfflineFallback: !this.isOnline(),
+            isExpired: expired,
+        });
+        return { hit: true, value: record.value };
+    }
+    async writeRecord(key, descriptor, effective, value) {
+        const now = Date.now();
+        const record = {
+            key,
+            scope: this.scope,
+            kind: descriptor.kind,
+            value,
+            cachedAt: now,
+            lastAccessedAt: now,
+            expiresAt: effective.retentionMs > 0 ? now + effective.retentionMs : null,
+            serverUpdatedAt: descriptor.serverUpdatedAt?.(value) ?? null,
+            schemaVersion: SCHEMA_VERSION,
+            ...(effective.policyId ? { policyId: effective.policyId } : {}),
+        };
+        await this.storage.setJson(key, record);
+    }
+    async writePolicyDerivedRecords(descriptor, effective, value) {
+        if (descriptor.kind !== "messages.list" || !descriptor.agentId || !descriptor.channelName) {
+            return;
+        }
+        if (!Array.isArray(value))
+            return;
+        await this.writeLatestMessagesRecord(descriptor.agentId, descriptor.channelName, value, effective);
+    }
+    async writeLatestMessagesRecord(agentId, channelName, messages, effective) {
+        const policy = this.matchPolicy(agentId, channelName);
+        if (!policy && !effective)
+            return;
+        if (policy?.cache === false)
+            return;
+        const retentionMs = effective?.retentionMs ?? policy?.retentionMs ?? this.defaultRetentionMs;
+        const count = policy?.messages?.count ?? messages.length;
+        const pruned = pruneLatestMessages(messages, count);
+        const descriptor = {
+            operation: "messages.latest",
+            kind: "messages.latest",
+            keyParts: this.latestMessagesKeyParts(agentId, channelName),
+            agentId,
+            channelName,
+            serverUpdatedAt: newestMessageTimestamp,
+        };
+        await this.writeRecord(this.cacheKey(descriptor), descriptor, {
+            enabled: true,
+            mode: "network-first",
+            retentionMs,
+            allowExpired: false,
+            ...(effective?.policyId || policy?.id ? { policyId: effective?.policyId ?? policy?.id } : {}),
+        }, pruned);
+    }
+    async mergeLatestMessage(agentId, channelName, message) {
+        const policy = this.matchPolicy(agentId, channelName);
+        if (!policy || policy.cache === false)
+            return;
+        const descriptor = {
+            operation: "messages.latest",
+            kind: "messages.latest",
+            keyParts: this.latestMessagesKeyParts(agentId, channelName),
+            agentId,
+            channelName,
+            serverUpdatedAt: newestMessageTimestamp,
+        };
+        const key = this.cacheKey(descriptor);
+        const existing = await this.storage.getJson(key);
+        const current = existing?.value ?? [];
+        const withoutDuplicate = current.filter((item) => item.id !== message.id);
+        await this.writeLatestMessagesRecord(agentId, channelName, [...withoutDuplicate, message], {
+            enabled: true,
+            mode: "network-first",
+            retentionMs: policy.retentionMs ?? this.defaultRetentionMs,
+            allowExpired: false,
+            ...(policy.id ? { policyId: policy.id } : {}),
+        });
+    }
+    async persistGatewayMessage(message) {
+        await this.mergeLatestMessage(message.channel.agent_id, message.channel.name, message);
+        const descriptor = {
+            operation: "messages.getMessage",
+            kind: "messages.get",
+            keyParts: ["messages", "get", [{ agentId: message.channel.agent_id, channelName: message.channel.name }, message.id], message.id],
+            agentId: message.channel.agent_id,
+            channelName: message.channel.name,
+            serverUpdatedAt: (value) => typeof value?.timestamp === "number"
+                ? value.timestamp
+                : undefined,
+        };
+        const policy = this.matchPolicy(message.channel.agent_id, message.channel.name);
+        if (!policy || policy.cache === false)
+            return;
+        await this.writeRecord(this.cacheKey(descriptor), descriptor, {
+            enabled: true,
+            mode: "network-first",
+            retentionMs: policy.retentionMs ?? this.defaultRetentionMs,
+            allowExpired: false,
+            ...(policy.id ? { policyId: policy.id } : {}),
+        }, message);
+    }
+    async persistGatewayAggregate(channel, aggregate) {
+        const policy = this.matchPolicy(channel.agent_id, channel.name);
+        if (!policy || policy.cache === false)
+            return;
+        const descriptor = {
+            operation: "aggregates.getAggregate",
+            kind: "aggregates.get",
+            keyParts: ["aggregates", "get", [{ agentId: channel.agent_id, channelName: channel.name }]],
+            agentId: channel.agent_id,
+            channelName: channel.name,
+            serverUpdatedAt: (value) => typeof value?.last_updated === "number"
+                ? value.last_updated
+                : undefined,
+        };
+        await this.writeRecord(this.cacheKey(descriptor), descriptor, {
+            enabled: true,
+            mode: "network-first",
+            retentionMs: policy.retentionMs ?? this.defaultRetentionMs,
+            allowExpired: false,
+            ...(policy.id ? { policyId: policy.id } : {}),
+        }, aggregate);
+    }
+    effectivePolicy(descriptor) {
+        const cache = descriptor.request?.cache;
+        const cacheOptions = cache === false ? undefined : cache;
+        const matching = this.matchPolicy(descriptor.agentId, descriptor.channelName);
+        const enabled = cache === false ? false :
+            cacheOptions?.enabled !== undefined ? cacheOptions.enabled :
+                matching ? matching.cache !== false :
+                    cache !== undefined;
+        return {
+            enabled,
+            mode: cacheOptions?.mode ?? "network-first",
+            retentionMs: cacheOptions?.retentionMs !== undefined
+                ? cacheOptions.retentionMs
+                : matching?.retentionMs ?? this.defaultRetentionMs,
+            allowExpired: !!cacheOptions?.allowExpired,
+            ...(cacheOptions?.policy ? { policyId: cacheOptions.policy } : matching?.id ? { policyId: matching.id } : {}),
+        };
+    }
+    matchPolicy(agentId, channelName) {
+        if (!channelName)
+            return undefined;
+        return this.policies.find((policy) => policy.channel.channelName === channelName &&
+            (policy.channel.agentId === undefined || policy.channel.agentId === agentId));
+    }
+    shouldCacheAttachmentBlob(descriptor) {
+        const policy = this.matchPolicy(descriptor.agentId, descriptor.channelName);
+        if (!policy)
+            return descriptor.request?.cache !== undefined && descriptor.request.cache !== false;
+        if (descriptor.kind === "messages.attachment") {
+            return policy.messageAttachments?.include === "metadata-and-selected-blobs";
+        }
+        if (descriptor.kind === "aggregates.attachment") {
+            return policy.aggregateAttachments?.include === "metadata-and-selected-blobs";
+        }
+        return false;
+    }
+    withDelegateOptions(args, request) {
+        const delegate = delegateRequestOptions(request);
+        return delegate ? [...args, delegate] : args;
+    }
+    cacheKey(descriptor) {
+        return `${this.scopePrefix(this.scope)}:${stableStringify({
+            kind: descriptor.kind,
+            keyParts: descriptor.keyParts,
+            sources: descriptor.request?.sources ? [...descriptor.request.sources].sort() : undefined,
+        })}`;
+    }
+    latestMessagesKeyParts(agentId, channelName) {
+        return ["messages", "latest", { agentId, channelName }];
+    }
+    scopePrefix(scope) {
+        return `doover-offline:v${SCHEMA_VERSION}:${stableStringify({
+            userId: scope.userId,
+            organisationId: scope.organisationId ?? null,
+            sourceId: scope.sourceId ?? "default",
+            sharing: scope.sharing ?? null,
+            assumeUserId: scope.assumeUserId ?? null,
+        })}`;
+    }
+    isOnline() {
+        if (this.isOnlineFn)
+            return this.isOnlineFn();
+        return this.networkStatus.getSnapshot().online;
+    }
+    setOfflineStatus(status) {
+        this.offlineStatus = {
+            ...status,
+            online: this.isOnline(),
+            at: Date.now(),
+        };
+        this.offlineStatusListeners.forEach((listener) => listener(this.offlineStatus));
+    }
+    enqueuePersist(task) {
+        this.persistQueue = this.persistQueue
+            .then(task)
+            .catch(() => undefined);
+    }
+}
+function extractAgentId(args) {
+    return typeof args[0] === "string"
+        ? args[0]
+        : args[0]?.agentId;
+}
+function extractChannelId(args) {
+    if (typeof args[0] === "string") {
+        return { agentId: args[0], channelName: args[1] };
+    }
+    const id = args[0];
+    return { agentId: id?.agentId, channelName: id?.channelName };
+}
+function newestMessageTimestamp(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    let newest = null;
+    for (const message of value) {
+        const timestamp = message.timestamp;
+        if (typeof timestamp === "number" && (newest === null || timestamp > newest)) {
+            newest = timestamp;
+        }
+    }
+    return newest;
+}
+function pruneLatestMessages(messages, count) {
+    if (count <= 0)
+        return [];
+    const byId = new Map();
+    for (const message of messages)
+        byId.set(message.id, message);
+    return [...byId.values()]
+        .sort((a, b) => a.timestamp - b.timestamp)
+        .slice(-count);
+}
+function isLikelyWrite(method) {
+    return /^(create|put|patch|post|delete|update|sync|archive|unarchive|test|regenerate|invoke)/.test(method);
+}
+function stableStringify(value) {
+    return JSON.stringify(sortForStringify(value));
+}
+function sortForStringify(value) {
+    if (Array.isArray(value))
+        return value.map(sortForStringify);
+    if (!value || typeof value !== "object")
+        return value;
+    const record = value;
+    return Object.keys(record).sort().reduce((acc, key) => {
+        const inner = record[key];
+        if (inner !== undefined)
+            acc[key] = sortForStringify(inner);
+        return acc;
+    }, {});
+}
+function scopeMatches(candidate, wanted) {
+    return (candidate.userId === wanted.userId &&
+        (wanted.organisationId === undefined || candidate.organisationId === wanted.organisationId) &&
+        (wanted.sourceId === undefined || candidate.sourceId === wanted.sourceId) &&
+        (wanted.sharing === undefined || candidate.sharing === wanted.sharing) &&
+        (wanted.assumeUserId === undefined || candidate.assumeUserId === wanted.assumeUserId));
+}