@pmate/chat-sdk 0.12.0-next.67 → 0.12.0-next.69

package/lib/chatContract.d.ts

@@ -0,0 +1,144 @@
+import type { ChatError } from "./chatError.js";
+import type { ChatMention } from "./mentions/model.js";
+import type { TokenProvider } from "./credentials.js";
+import type { ChatGroup, ChatSnapshot, ChatThreadSnapshot, ReadOptions } from "./chatTypes.js";
+export type { TokenProvider, TokenRequest } from "./credentials.js";
+export type ConversationTarget = {
+    peerId: string;
+    groupId?: never;
+} | {
+    groupId: string;
+    peerId?: never;
+};
+export type CreateChatOptions = {
+    appId: string;
+    accountId: string;
+    profileId: string;
+    teamId: string;
+    threadId?: string;
+    endpoint?: string;
+    uploadEndpoint?: string;
+    clientInstanceId?: string;
+    fetch?: typeof fetch;
+    onError?: (error: ChatError) => void;
+} & ({
+    token: string;
+    getToken?: never;
+} | {
+    getToken: TokenProvider;
+    token?: never;
+});
+export type SendOptions = {
+    waitFor?: "accepted" | "delivered";
+};
+export type SentMessage = Readonly<{
+    id: string;
+    timestamp: number;
+}>;
+export type ReadersQuery = {
+    afterProfileId?: string;
+    revision?: number;
+};
+export type ReadersPage = Readonly<{
+    appId: string;
+    threadId: string;
+    messageId: string;
+    revision: number;
+    total: number;
+    profileIds: string[];
+    nextAfter: string | null;
+    resetRequired: boolean;
+}>;
+export type GroupChanges = {
+    expectedRevision?: string;
+    addMembers?: readonly string[];
+    removeMembers?: readonly string[];
+    title?: string;
+    avatar?: string;
+};
+export type VoiceAttachment = Readonly<{
+    url: string;
+    release: () => void;
+}>;
+export type SubscribeOptions<T> = {
+    fields?: readonly (keyof T)[];
+};
+type ContentChoices = {
+    text: {
+        text: string;
+        mentions?: ChatMention[];
+        quote?: {
+            messageId?: string;
+            senderName: string;
+            content: string;
+        };
+    };
+    image: {
+        image: {
+            url: string;
+            name?: string;
+        };
+    };
+    voice: {
+        voice: ({
+            blob: Blob;
+            url?: never;
+        } | {
+            url: string;
+            blob?: never;
+        }) & {
+            durationMs: number;
+            transcript?: string;
+        };
+    };
+    recall: {
+        recall: {
+            messageId: string;
+        };
+    };
+    reaction: {
+        reaction: {
+            messageId: string;
+            emojiId: string;
+            active: boolean;
+        };
+    };
+    invitation: {
+        invitation: {
+            message?: string;
+        };
+    };
+};
+export type OutgoingContent = {
+    [K in keyof ContentChoices]: ContentChoices[K] & {
+        [P in Exclude<keyof ContentChoices, K>]?: never;
+    };
+}[keyof ContentChoices];
+/** Default public client. Protocol and synchronous store internals are separate entry points. */
+export interface Chat {
+    start(): Promise<void>;
+    close(): Promise<void>;
+    resolveThreadId(target: ConversationTarget, options?: ReadOptions): Promise<string>;
+    getThread(threadId: string, options?: ReadOptions): Promise<ChatThreadSnapshot>;
+    loadEarlier(threadId: string, options?: ReadOptions): Promise<ChatThreadSnapshot>;
+    refreshThread(threadId: string, options?: ReadOptions): Promise<ChatThreadSnapshot>;
+    subscribeThread(threadId: string, listener: (snapshot: ChatThreadSnapshot) => void, options?: SubscribeOptions<ChatThreadSnapshot>): () => void;
+    subscribeChat(listener: (snapshot: ChatSnapshot) => void, options?: SubscribeOptions<ChatSnapshot>): () => void;
+    sendMessage(threadId: string, content: OutgoingContent, options?: SendOptions): Promise<SentMessage>;
+    retryMessage(messageId: string): Promise<SentMessage>;
+    observeMessages(threadId: string, ids: string[], event: "visible" | "played"): Promise<void>;
+    markRead(threadId: string): Promise<void>;
+    getReaders(threadId: string, messageId: string, options?: ReadersQuery & ReadOptions): Promise<ReadersPage>;
+    watchReaders(threadId: string | undefined, ids: string[], receiver?: string): Promise<void>;
+    getVoiceAttachment(threadId: string, messageId: string, options?: ReadOptions): Promise<VoiceAttachment>;
+    getGroup(threadId: string, options?: ReadOptions): Promise<ChatGroup>;
+    refreshGroup(threadId: string, options?: ReadOptions): Promise<ChatGroup>;
+    createGroup(input: {
+        groupId?: string;
+        title: string;
+        members: readonly string[];
+    }): Promise<ChatGroup & {
+        threadId: string;
+    }>;
+    updateGroup(threadId: string, changes: GroupChanges): Promise<ChatGroup>;
+}

package/lib/chatContract.js

@@ -0,0 +1 @@
+export {};

package/lib/chatError.d.ts

@@ -0,0 +1,11 @@
+export type ChatErrorCode = "unavailable" | "access-denied" | "authentication-required" | "storage-unavailable" | "invalid-input" | "conflict" | "closed" | "busy";
+/** Stable recovery categories. The original failure remains available as cause. */
+export declare class ChatError extends Error {
+    readonly code: ChatErrorCode;
+    readonly retryable: boolean;
+    readonly status?: number;
+    constructor(code: ChatErrorCode, message: string, options?: {
+        cause?: unknown;
+        status?: number;
+    });
+}

package/lib/chatError.js

@@ -0,0 +1,13 @@
+/** Stable recovery categories. The original failure remains available as cause. */
+export class ChatError extends Error {
+    code;
+    retryable;
+    status;
+    constructor(code, message, options = {}) {
+        super(message, { cause: options.cause });
+        this.code = code;
+        this.name = "ChatError";
+        this.status = options.status;
+        this.retryable = ["unavailable", "storage-unavailable", "busy"].includes(code);
+    }
+}

package/lib/chatTypes.d.ts

@@ -0,0 +1,119 @@
+import type { ChatError } from "./chatError.js";
+import type { ChatMention } from "./mentions/model.js";
+/** Stable product model. No storage, transport, Session or projection types. */
+export type ChatMessage = Readonly<{
+    id: string;
+    threadId: string;
+    timestamp: number;
+    from?: string;
+    mine: boolean;
+    status: "sending" | "sent" | "failed" | "read";
+    recalled: boolean;
+    unread?: boolean;
+    attentionEligible?: boolean;
+    reading?: Readonly<{
+        seq?: number;
+        read: boolean;
+        readPolicy: "visible" | "explicit";
+    }>;
+    reactions: readonly Readonly<{
+        emojiId: string;
+        userIds: string[];
+        mine: boolean;
+    }>[];
+    kind: "text" | "image" | "voice" | "emoji" | "quote" | "invitation" | "system" | "attachment";
+    text: string;
+    senderName?: string;
+    senderAvatar?: string;
+    timeLabel?: string;
+    image?: Readonly<{
+        url: string;
+        name?: string;
+    }>;
+    voice?: Readonly<{
+        url: string;
+        durationMs: number;
+        transcript?: string;
+    }>;
+    quote?: Readonly<{
+        messageId?: string;
+        senderName: string;
+        content: string;
+        recalled?: boolean;
+    }>;
+    attachment?: Readonly<{
+        name?: string;
+        size?: string;
+    }>;
+    richContent?: unknown;
+    mentions?: readonly ChatMention[];
+    recipientCount?: number;
+    system?: Readonly<{
+        type: "group-created" | "group-updated" | "contact-updated";
+        title?: string;
+    }>;
+}>;
+export type ChatGroup = Readonly<{
+    groupId: string;
+    teamId: string;
+    ownerId: string;
+    title: string;
+    avatar?: string;
+    memberIds: readonly string[];
+    revision: string;
+}>;
+export type ConversationInfo = Readonly<{
+    kind: "dm" | "group";
+    targetId: string;
+}>;
+export type UnreadState = Readonly<{
+    unreadMessageCount: number;
+    unreadMentionCount: number;
+    badgeCount: number;
+}>;
+export type ReadCounts = Readonly<{
+    appId: string;
+    threadId: string;
+    revision: number;
+    counts: Record<string, number>;
+}>;
+type ThreadFields = Readonly<{
+    threadId: string;
+    messages: readonly ChatMessage[];
+    hasEarlier: boolean;
+    conversation?: ConversationInfo;
+    unread: UnreadState | undefined;
+    group: ChatGroup | undefined;
+    readCounts: ReadCounts | undefined;
+}>;
+/** A refresh failure retains ready data; only an initial failure has status error. */
+export type ChatThreadSnapshot = ThreadFields & (Readonly<{
+    status: "pending";
+    ready: false;
+    error?: undefined;
+}> | Readonly<{
+    status: "ready";
+    ready: true;
+    error?: ChatError;
+}> | Readonly<{
+    status: "error";
+    ready: false;
+    error: ChatError;
+}>);
+export type ChatConnectionState = "connecting" | "reconnecting" | "authenticating" | "connected" | "authentication_required" | "closed";
+export type ChatSnapshot = Readonly<{
+    threads: readonly {
+        threadId: string;
+        lastMessage?: ChatMessage;
+        group: ChatGroup | undefined;
+        unread: UnreadState | undefined;
+        outgoingCount: number;
+    }[];
+    unreadMessageCount: number | undefined;
+    badgeCount: number | undefined;
+    connection: ChatConnectionState;
+}>;
+export type ReadOptions = {
+    signal?: AbortSignal;
+};
+export {};

package/lib/chatTypes.js

@@ -0,0 +1 @@
+export {};

package/lib/credentials.d.ts

@@ -0,0 +1,26 @@
+export type TokenRequest = Readonly<{
+    forceRefresh: boolean;
+    signal: AbortSignal;
+}>;
+export type TokenProvider = (request: TokenRequest) => string | Promise<string>;
+/** Cancel the caller's wait, not the underlying shared operation. */
+export declare function waitForCaller<T>(task: Promise<T>, signal?: AbortSignal, onAbandonedValue?: (value: T) => void): Promise<T>;
+/** One scoped credential owner; stale 401s share one refresh rather than cascading. */
+export declare class ChatCredentials {
+    private provider;
+    private origin;
+    private transport;
+    private lifetime;
+    private flight?;
+    private refreshing?;
+    private latest?;
+    private recovery?;
+    private recoveredFrom;
+    private version;
+    constructor(provider: TokenProvider, origin: string, transport?: typeof fetch);
+    private acquire;
+    private recover;
+    getToken: () => Promise<string>;
+    fetch: typeof fetch;
+    close(): void;
+}

package/lib/credentials.js

@@ -0,0 +1,109 @@
+import { ChatError } from "./chatError.js";
+/** Cancel the caller's wait, not the underlying shared operation. */
+export function waitForCaller(task, signal, onAbandonedValue) {
+    if (!signal)
+        return task;
+    if (signal.aborted) {
+        void task.then(value => onAbandonedValue?.(value), () => { });
+        return Promise.reject(signal.reason ?? new DOMException("Aborted", "AbortError"));
+    }
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        const abort = () => { if (settled)
+            return; settled = true; signal.removeEventListener("abort", abort); reject(signal.reason ?? new DOMException("Aborted", "AbortError")); };
+        signal.addEventListener("abort", abort, { once: true });
+        task.then(value => { signal.removeEventListener("abort", abort); if (settled) {
+            onAbandonedValue?.(value);
+            return;
+        } settled = true; resolve(value); }, error => { signal.removeEventListener("abort", abort); if (!settled) {
+            settled = true;
+            reject(error);
+        } });
+    });
+}
+/** One scoped credential owner; stale 401s share one refresh rather than cascading. */
+export class ChatCredentials {
+    provider;
+    origin;
+    transport;
+    lifetime = new AbortController();
+    flight;
+    refreshing;
+    latest;
+    recovery;
+    recoveredFrom = -1;
+    version = 0;
+    constructor(provider, origin, transport = fetch) {
+        this.provider = provider;
+        this.origin = origin;
+        this.transport = transport;
+    }
+    acquire(forceRefresh = false) {
+        if (this.lifetime.signal.aborted)
+            return Promise.reject(new ChatError("closed", "Chat credentials closed"));
+        if (this.refreshing)
+            return this.refreshing;
+        if (!forceRefresh && this.flight)
+            return this.flight;
+        const version = forceRefresh ? ++this.version : this.version;
+        const signal = AbortSignal.any([this.lifetime.signal, AbortSignal.timeout(15000)]);
+        const task = waitForCaller(Promise.resolve().then(() => this.provider({ forceRefresh, signal })), signal).then(token => {
+            if (this.lifetime.signal.aborted)
+                throw new ChatError("closed", "Chat credentials closed");
+            if (typeof token !== "string" || !token.trim())
+                throw new ChatError("authentication-required", "A valid access token is required");
+            if (version < this.version && this.latest)
+                return this.latest;
+            const value = { token, version };
+            this.latest = value;
+            return value;
+        }).catch(error => {
+            if (error?.status === 401)
+                throw new ChatError("authentication-required", "Credentials require a fresh login", { cause: error, status: 401 });
+            if (error?.status === 403)
+                throw new ChatError("access-denied", "Credential access denied", { cause: error, status: 403 });
+            throw error;
+        }).finally(() => { if (this.flight === task)
+            this.flight = undefined; if (this.refreshing === task)
+            this.refreshing = undefined; });
+        if (forceRefresh)
+            this.refreshing = task;
+        else
+            this.flight = task;
+        return task;
+    }
+    recover(used) {
+        if (this.latest && this.latest.version > used.version)
+            return Promise.resolve(this.latest);
+        if (this.recovery && used.version <= this.recoveredFrom)
+            return this.recovery;
+        this.recoveredFrom = used.version;
+        this.recovery = this.acquire(true);
+        return this.recovery;
+    }
+    getToken = async () => { return (await this.acquire()).token; };
+    fetch = async (input, init) => {
+        const url = new URL(input instanceof Request ? input.url : String(input)), headers = new Headers(init?.headers ?? (input instanceof Request ? input.headers : undefined));
+        // Never attach an app credential to uploads, other origins or unauthenticated requests.
+        if (url.origin !== this.origin || !headers.has("authorization"))
+            return this.transport(input, init);
+        const callerSignal = init?.signal ?? (input instanceof Request ? input.signal : undefined);
+        const signal = AbortSignal.any([this.lifetime.signal, ...(callerSignal ? [callerSignal] : [])]);
+        signal?.throwIfAborted();
+        const original = input instanceof Request ? input.clone() : input;
+        const send = async (token) => {
+            signal?.throwIfAborted();
+            headers.set("authorization", `Bearer ${token}`);
+            return this.transport(original instanceof Request ? original.clone() : original, { ...init, headers, signal });
+        };
+        const used = await waitForCaller(this.acquire(), signal ?? undefined);
+        const response = await send(used.token);
+        if (response.status !== 401)
+            return response;
+        // Denial (403) is terminal. Only an unauthenticated response gets one replay.
+        void response.body?.cancel().catch(() => { });
+        const next = await waitForCaller(this.recover(used), signal);
+        return send(next.token);
+    };
+    close() { this.lifetime.abort(new ChatError("closed", "Chat credentials closed")); }
+}

package/lib/framework.d.ts

@@ -0,0 +1,11 @@
+import type { Chat } from "./chatContract.js";
+import type { ChatSnapshot, ChatThreadSnapshot } from "./chatTypes.js";
+export interface ChatStore {
+    subscribeThread(threadId: string, listener: () => void, fields?: readonly (keyof ChatThreadSnapshot)[]): () => void;
+    getSnapshot(): ChatSnapshot;
+    getSnapshot(threadId: string): ChatThreadSnapshot;
+    subscribeChanges(listener: () => void): () => void;
+    subscribeChanges(threadId: string, listener: () => void, fields?: readonly (keyof ChatThreadSnapshot)[]): () => void;
+}
+/** Synchronous memory reads are for external-store integrations, not cache selection. */
+export declare function getChatStore(chat: Chat): ChatStore;

package/lib/framework.js

@@ -0,0 +1,12 @@
+import { chatEngine } from "./internal/chatRegistry.js";
+const stores = new WeakMap();
+/** Synchronous memory reads are for external-store integrations, not cache selection. */
+export function getChatStore(chat) {
+    let store = stores.get(chat);
+    if (!store) {
+        const engine = chatEngine(chat);
+        store = { subscribeThread: (id, listener, fields) => engine.subscribeThread(id, listener, { fields, emitCurrent: false }), getSnapshot: ((id) => id === undefined ? engine.getSnapshot() : engine.getSnapshot(id)), subscribeChanges: ((target, callback, fields) => typeof target === "function" ? engine.subscribe(target, { emitCurrent: false }) : engine.subscribe(target, callback, { fields, emitCurrent: false })) };
+        stores.set(chat, store);
+    }
+    return store;
+}

package/lib/history.d.ts

@@ -0,0 +1,4 @@
+import type { Chat } from "./chatContract.js";
+import type { ChatThreadSnapshot, ReadOptions } from "./chatTypes.js";
+/** Explicit complete-history operation for search/export; may scan many pages. */
+export declare function loadThreadHistory(chat: Chat, threadId: string, { signal }?: ReadOptions): Promise<ChatThreadSnapshot>;

package/lib/history.js

@@ -0,0 +1,8 @@
+import { chatEngine } from "./internal/chatRegistry.js";
+import { waitForCaller } from "./credentials.js";
+/** Explicit complete-history operation for search/export; may scan many pages. */
+export function loadThreadHistory(chat, threadId, { signal } = {}) {
+    if (signal?.aborted)
+        return Promise.reject(signal.reason ?? new DOMException("Aborted", "AbortError"));
+    return waitForCaller(chatEngine(chat).getMessages(threadId, { all: true }), signal);
+}

package/lib/hooks/useChatSnapshot.js

@@ -1,8 +1,9 @@
 import { useCallback, useSyncExternalStore } from "react";
+import { getChatStore } from "../framework.js";
 const emptySummary = Object.freeze({ threads: [], unreadMessageCount: undefined, badgeCount: undefined, connection: "closed" });
-const emptyThread = Object.freeze({ threadId: "", messages: [], ready: false, hasEarlier: false, unread: undefined, group: undefined, readCounts: undefined });
+const emptyThread = Object.freeze({ threadId: "", messages: [], status: "pending", ready: false, hasEarlier: false, unread: undefined, group: undefined, readCounts: undefined });
 export function useChatSnapshot(chat, threadId) {
-    const subscribe = useCallback((notify) => !chat ? () => { } : threadId === undefined ? chat.subscribe(notify, { emitCurrent: false }) : chat.subscribe(threadId, notify, { emitCurrent: false }), [chat, threadId]);
-    const snapshot = useCallback(() => threadId === undefined ? chat?.getSnapshot() ?? emptySummary : chat?.getSnapshot(threadId) ?? emptyThread, [chat, threadId]);
+    const subscribe = useCallback((notify) => !chat ? () => { } : threadId === undefined ? getChatStore(chat).subscribeChanges(notify) : getChatStore(chat).subscribeThread(threadId, notify), [chat, threadId]);
+    const snapshot = useCallback(() => threadId === undefined ? (chat ? getChatStore(chat).getSnapshot() : undefined) ?? emptySummary : (chat ? getChatStore(chat).getSnapshot(threadId) : undefined) ?? emptyThread, [chat, threadId]);
     return useSyncExternalStore(subscribe, snapshot, () => threadId === undefined ? emptySummary : emptyThread);
 }

package/lib/index.d.ts

@@ -41,5 +41,5 @@ export * from "./runtime/socialReadClient";
 export * from "./ux/imagePaste";
 export * from "./hooks/useImageAttachments";
 export * from "./components/ImageAttachmentTray";
-export { createChat, Chat, ChatError, type ChatThreadSnapshot, type ChatMessage as MessageView, type ChatErrorCode, type ConversationTarget, type OutgoingContent, type CreateChatOptions, type ChatSnapshot, type SentMessage, type MessageQuery, type ReadersQuery, type GroupChanges } from "./chat.js";
+export { createChat, type Chat, ChatError, type ChatThreadSnapshot, type ChatMessage as MessageView, type ChatErrorCode, type ConversationTarget, type OutgoingContent, type CreateChatOptions, type ChatSnapshot, type SentMessage, type ReadOptions, type ReadersQuery, type GroupChanges } from "./chat.js";
 export { useChatSnapshot } from "./hooks/useChatSnapshot.js";

package/lib/index.js

@@ -41,5 +41,5 @@ export * from "./runtime/socialReadClient";
 export * from "./ux/imagePaste";
 export * from "./hooks/useImageAttachments";
 export * from "./components/ImageAttachmentTray";
-export { createChat, Chat, ChatError } from "./chat.js";
+export { createChat, ChatError } from "./chat.js";
 export { useChatSnapshot } from "./hooks/useChatSnapshot.js";

package/lib/internal/chatEngine.d.ts

@@ -0,0 +1,131 @@
+export type { ChatMessage } from "../chatTypes.js";
+import { type CreateChatOptions } from "../runtime/createChat.js";
+import type { ChatSession } from "../runtime/chatSession.js";
+import type { CachedChatMessage } from "../runtime/cachedMessage.js";
+import type { ConversationTarget } from "../runtime/conversationDirectory.js";
+import type { OutgoingContent as RuntimeContent } from "../runtime/outgoingContent.js";
+export { ChatError } from "../chatError.js";
+export type { ChatErrorCode } from "../chatError.js";
+export type { CreateChatOptions, ConversationTarget };
+export type OutgoingContent = Exclude<RuntimeContent, {
+    groupCreate: unknown;
+} | {
+    groupUpdate: unknown;
+}>;
+import type { ChatThreadSnapshot, ChatSnapshot, ReadOptions } from "../chatTypes.js";
+export type { ChatGroup, ConversationInfo, ChatThreadSnapshot, ChatSnapshot, ReadOptions } from "../chatTypes.js";
+export type MessageQuery = {
+    earlier?: boolean;
+    all?: boolean;
+    refresh?: boolean;
+};
+export type ReadersQuery = {
+    afterProfileId?: string;
+    revision?: number;
+};
+export type GroupChanges = {
+    expectedRevision?: string;
+    addMembers?: readonly string[];
+    removeMembers?: readonly string[];
+    title?: string;
+    avatar?: string;
+};
+export type SendOptions = {
+    waitFor?: "accepted" | "delivered";
+};
+export type SentMessage = Readonly<{
+    id: string;
+    timestamp: number;
+}>;
+type SubscribeOptions<T> = {
+    fields?: readonly (keyof T)[];
+    emitCurrent?: boolean;
+};
+/** App-facing API. Cache coverage, raw protocol and synchronization stay in advanced. */
+export declare class ChatEngine {
+    readonly advanced: ChatSession<CachedChatMessage>;
+    private options;
+    private groups;
+    private group;
+    private present;
+    private redactedQuotes;
+    private messageLists;
+    private messages;
+    private views;
+    private summary?;
+    private targets;
+    private errors;
+    private listeners;
+    private closed;
+    constructor(advanced: ChatSession<CachedChatMessage>, options: CreateChatOptions);
+    private operation;
+    private deny;
+    private threadOperation;
+    start(): Promise<void>;
+    /** Resolve a scoped ID locally, registering its target when needed. No remote group is created. */
+    resolveThreadId(target: ConversationTarget): Promise<string>;
+    /** A trusted recent window. Source selection and synchronization belong to the SDK. */
+    getThread(threadId: string, options?: ReadOptions): Promise<ChatThreadSnapshot>;
+    loadEarlier(threadId: string, options?: ReadOptions): Promise<ChatThreadSnapshot>;
+    refreshThread(threadId: string, options?: ReadOptions): Promise<ChatThreadSnapshot>;
+    private readForCaller;
+    private threadSubscribers;
+    private openQueue;
+    private opening;
+    private drainOpens;
+    /** Listen first, then open the local window; concurrent consumers share the initial read. */
+    subscribeThread(threadId: string, listener: (snapshot: ChatThreadSnapshot) => void, options?: SubscribeOptions<ChatThreadSnapshot>): () => void;
+    /** @deprecated Use resolveThreadId. Retained only for the migration window. */
+    getConversation(target: ConversationTarget): Promise<string>;
+    getSnapshot(): ChatSnapshot;
+    getSnapshot(threadId: string): ChatThreadSnapshot;
+    getMessages(threadId: string, query?: MessageQuery): Promise<ChatThreadSnapshot>;
+    sendMessage(threadId: string, content: OutgoingContent, options?: SendOptions): Promise<SentMessage>;
+    retryMessage(messageId: string): Promise<SentMessage>;
+    subscribe(listener: (snapshot: ChatSnapshot) => void, options?: SubscribeOptions<ChatSnapshot>): () => void;
+    subscribe(threadId: string, listener: (snapshot: ChatThreadSnapshot) => void, options?: SubscribeOptions<ChatThreadSnapshot>): () => void;
+    private sessionFields;
+    private notify;
+    observeMessages(threadId: string, ids: string[], event: "visible" | "played"): Promise<void>;
+    markRead(threadId: string): Promise<void>;
+    getReaders(threadId: string, messageId: string, page?: ReadersQuery, signal?: AbortSignal): Promise<import("../runtime/messageReaders.js").MessageReadersPage>;
+    watchReaders(threadId: string | undefined, ids: string[], receiver?: string): Promise<void>;
+    handleReach(event: Parameters<ChatSession<CachedChatMessage>["handleReach"]>[0]): Promise<"handled" | undefined>;
+    getVoiceAttachment(threadId: string, messageId: string): Promise<import("../runtime/durableSender.js").VoiceAttachmentLease>;
+    getGroup(threadId: string, options?: {
+        refresh?: boolean;
+    }): Promise<Readonly<{
+        groupId: string;
+        teamId: string;
+        ownerId: string;
+        title: string;
+        avatar?: string;
+        memberIds: readonly string[];
+        revision: string;
+    }>>;
+    createGroup(input: {
+        groupId?: string;
+        title: string;
+        members: readonly string[];
+    }): Promise<{
+        threadId: string;
+        groupId: string;
+        teamId: string;
+        ownerId: string;
+        title: string;
+        avatar?: string;
+        memberIds: readonly string[];
+        revision: string;
+    }>;
+    updateGroup(threadId: string, changes: GroupChanges): Promise<Readonly<{
+        groupId: string;
+        teamId: string;
+        ownerId: string;
+        title: string;
+        avatar?: string;
+        memberIds: readonly string[];
+        revision: string;
+    }>>;
+    revokeAccess(): Promise<void>;
+    close(): Promise<void>;
+}