@massalabs/gossip-sdk 0.0.2-dev.20260220052400 → 0.0.2-dev.20260220075254

package/README.md

@@ -352,7 +352,7 @@ npm test           # Watch mode
 npm run test:run   # Single run
 ```
 
-Tests use `fake-indexeddb` to simulate IndexedDB in Node.js environment.
+Tests use wa-sqlite with in-memory databases for fast, isolated execution.
 
 ## Architecture
 
@@ -360,7 +360,7 @@ Tests use `fake-indexeddb` to simulate IndexedDB in Node.js environment.
 gossip-sdk/
 ├── src/
 │   ├── gossipSdk.ts      # SDK class & factory
-│   ├── db.ts             # Database (Dexie) implementation
+│   ├── db.ts             # Database (SQLite) implementation
 │   ├── contacts.ts       # Contact operations
 │   ├── api/
 │   │   └── messageProtocol/  # REST protocol implementation

package/dist/api/authProtocol.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Auth Protocol — public key publishing & retrieval
+ */
+import { RestClient } from './restClient';
+export interface IAuthProtocol {
+    /** Fetches the base64-encoded public key for the given user ID. */
+    fetchPublicKeyByUserId(userId: Uint8Array): Promise<string>;
+    /** Publishes the given base64-encoded public key to the server. */
+    postPublicKey(base64PublicKeys: string): Promise<string>;
+}
+export declare function createAuthProtocol(config?: Partial<{
+    baseUrl: string;
+    timeout: number;
+    retryAttempts: number;
+}>): IAuthProtocol;
+export declare class RestAuthProtocol extends RestClient implements IAuthProtocol {
+    fetchPublicKeyByUserId(userId: Uint8Array): Promise<string>;
+    postPublicKey(base64PublicKeys: string): Promise<string>;
+}

package/dist/api/authProtocol.js

@@ -0,0 +1,37 @@
+/**
+ * Auth Protocol — public key publishing & retrieval
+ */
+import { RestClient } from './restClient';
+import { encodeToBase64 } from '../utils/base64';
+import { protocolConfig } from '../config/protocol';
+export function createAuthProtocol(config) {
+    return new RestAuthProtocol(config?.baseUrl ?? protocolConfig.baseUrl, config?.timeout ?? protocolConfig.timeout, config?.retryAttempts ?? protocolConfig.retryAttempts);
+}
+export class RestAuthProtocol extends RestClient {
+    async fetchPublicKeyByUserId(userId) {
+        const response = await this.makeRequest(`${this.baseUrl}/auth/retrieve`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ key: encodeToBase64(userId) }),
+        });
+        if (!response.success || !response.data) {
+            throw new Error(response.error || 'Failed to fetch public key');
+        }
+        if (!response.data.value) {
+            throw new Error('Public key not found');
+        }
+        return response.data.value;
+    }
+    async postPublicKey(base64PublicKeys) {
+        const url = `${this.baseUrl}/auth`;
+        const response = await this.makeRequest(url, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ value: base64PublicKeys }),
+        });
+        if (!response.success || !response.data) {
+            throw new Error(response.error || 'Failed to store public key');
+        }
+        return response.data.value;
+    }
+}

package/dist/api/messageProtocol/rest.d.ts

@@ -2,22 +2,16 @@
  * REST API implementation of the message protocol
  */
 import { BulletinItem, EncryptedMessage, IMessageProtocol, MessageProtocolResponse } from './types';
+import { RestClient } from '../restClient';
 export type BulletinsPage = {
     counter: string;
     data: string;
 }[];
-export declare class RestMessageProtocol implements IMessageProtocol {
-    private baseUrl;
-    private timeout;
-    private retryAttempts;
-    constructor(baseUrl: string, timeout?: number, retryAttempts?: number);
+export declare class RestMessageProtocol extends RestClient implements IMessageProtocol {
     fetchMessages(seekers: Uint8Array[]): Promise<EncryptedMessage[]>;
     sendMessage(message: EncryptedMessage): Promise<void>;
     sendAnnouncement(announcement: Uint8Array): Promise<string>;
     fetchAnnouncements(limit?: number, cursor?: string): Promise<BulletinItem[]>;
     fetchBulletinCounter(): Promise<string>;
-    fetchPublicKeyByUserId(userId: Uint8Array): Promise<string>;
-    postPublicKey(base64PublicKeys: string): Promise<string>;
-    private makeRequest;
     changeNode(nodeUrl?: string): Promise<MessageProtocolResponse>;
 }

package/dist/api/messageProtocol/rest.js

@@ -1,30 +1,11 @@
 /**
  * REST API implementation of the message protocol
  */
+import { RestClient } from '../restClient';
 import { encodeToBase64, decodeFromBase64 } from '../../utils/base64';
 const BULLETIN_ENDPOINT = '/bulletin';
 const MESSAGES_ENDPOINT = '/messages';
-export class RestMessageProtocol {
-    constructor(baseUrl, timeout = 10000, retryAttempts = 3) {
-        Object.defineProperty(this, "baseUrl", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: baseUrl
-        });
-        Object.defineProperty(this, "timeout", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: timeout
-        });
-        Object.defineProperty(this, "retryAttempts", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: retryAttempts
-        });
-    }
+export class RestMessageProtocol extends RestClient {
     // TODO: Implement a fetch with pagination to avoid fetching all messages at once
     async fetchMessages(seekers) {
         const url = `${this.baseUrl}${MESSAGES_ENDPOINT}/fetch`;
@@ -101,65 +82,6 @@ export class RestMessageProtocol {
         }
         return response.data.counter;
     }
-    async fetchPublicKeyByUserId(userId) {
-        const response = await this.makeRequest(`${this.baseUrl}/auth/retrieve`, {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({ key: encodeToBase64(userId) }),
-        });
-        if (!response.success || !response.data) {
-            throw new Error(response.error || 'Failed to fetch public key');
-        }
-        if (!response.data.value) {
-            throw new Error('Public key not found');
-        }
-        return response.data.value;
-    }
-    async postPublicKey(base64PublicKeys) {
-        const url = `${this.baseUrl}/auth`;
-        const response = await this.makeRequest(url, {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({ value: base64PublicKeys }),
-        });
-        if (!response.success || !response.data) {
-            const errorMessage = response.error || 'Failed to store public key';
-            throw new Error(errorMessage);
-        }
-        return response.data.value;
-    }
-    async makeRequest(url, options) {
-        let lastError = null;
-        for (let attempt = 1; attempt <= this.retryAttempts; attempt++) {
-            try {
-                const controller = new AbortController();
-                const timeoutId = setTimeout(() => controller.abort(), this.timeout);
-                const response = await fetch(url, {
-                    ...options,
-                    signal: controller.signal,
-                });
-                clearTimeout(timeoutId);
-                if (!response.ok) {
-                    throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-                }
-                const data = await response.json();
-                return { success: true, data };
-            }
-            catch (error) {
-                lastError = error;
-                console.warn(`Request attempt ${attempt} failed:`, error);
-                if (attempt < this.retryAttempts) {
-                    // Exponential backoff
-                    const delay = Math.pow(2, attempt) * 1000;
-                    await new Promise(resolve => setTimeout(resolve, delay));
-                }
-            }
-        }
-        return {
-            success: false,
-            error: lastError?.message || 'Request failed after all retry attempts',
-        };
-    }
     async changeNode(nodeUrl) {
         return {
             success: true,

package/dist/api/messageProtocol/types.d.ts

@@ -44,18 +44,6 @@ export interface IMessageProtocol {
      * Fetch the latest bulletin counter from the API without downloading announcement data.
      */
     fetchBulletinCounter(): Promise<string>;
-    /**
-     * Fetch public key by userId hash (base64 string)
-     * @param userId - Decoded userId bytes
-     * @returns Base64-encoded public keys
-     */
-    fetchPublicKeyByUserId(userId: Uint8Array): Promise<string>;
-    /**
-     * Store public key in the auth API
-     * @param base64PublicKeys - Base64-encoded public keys
-     * @returns The hash key (hex string) returned by the API
-     */
-    postPublicKey(base64PublicKeys: string): Promise<string>;
     /**
      * Change the current node provider
      * @param nodeUrl - The URL of the new node

package/dist/api/restClient.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Base REST client with retry and timeout support.
+ * Shared by RestMessageProtocol and RestAuthProtocol.
+ */
+export interface RestResponse<T = unknown> {
+    success: boolean;
+    data?: T;
+    error?: string;
+}
+export declare class RestClient {
+    protected baseUrl: string;
+    protected timeout: number;
+    protected retryAttempts: number;
+    constructor(baseUrl: string, timeout?: number, retryAttempts?: number);
+    protected makeRequest<T>(url: string, options: RequestInit): Promise<RestResponse<T>>;
+}

package/dist/api/restClient.js

@@ -0,0 +1,57 @@
+/**
+ * Base REST client with retry and timeout support.
+ * Shared by RestMessageProtocol and RestAuthProtocol.
+ */
+export class RestClient {
+    constructor(baseUrl, timeout = 10000, retryAttempts = 3) {
+        Object.defineProperty(this, "baseUrl", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: baseUrl
+        });
+        Object.defineProperty(this, "timeout", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: timeout
+        });
+        Object.defineProperty(this, "retryAttempts", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: retryAttempts
+        });
+    }
+    async makeRequest(url, options) {
+        let lastError = null;
+        for (let attempt = 1; attempt <= this.retryAttempts; attempt++) {
+            try {
+                const controller = new AbortController();
+                const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+                const response = await fetch(url, {
+                    ...options,
+                    signal: controller.signal,
+                });
+                clearTimeout(timeoutId);
+                if (!response.ok) {
+                    throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+                }
+                const data = await response.json();
+                return { success: true, data };
+            }
+            catch (error) {
+                lastError = error;
+                console.warn(`Request attempt ${attempt} failed:`, error);
+                if (attempt < this.retryAttempts) {
+                    const delay = Math.pow(2, attempt) * 1000;
+                    await new Promise(resolve => setTimeout(resolve, delay));
+                }
+            }
+        }
+        return {
+            success: false,
+            error: lastError?.message || 'Request failed after all retry attempts',
+        };
+    }
+}

package/dist/config/sdk.js

@@ -16,7 +16,7 @@ export const defaultSdkConfig = {
         enabled: false,
         messagesIntervalMs: 5000,
         announcementsIntervalMs: 10000,
-        sessionRefreshIntervalMs: 10000, //30000,
+        sessionRefreshIntervalMs: 10000,
     },
     messages: {
         fetchDelayMs: 100,

package/dist/contacts.d.ts

@@ -17,7 +17,7 @@
  * await deleteContact(userId, contactUserId);
  * ```
  */
-import { type Contact, type GossipDatabase } from './db';
+import { type Contact } from './db';
 import type { UpdateContactNameResult, DeleteContactResult } from './utils/contacts';
 import type { UserPublicKeys } from './wasm/bindings';
 import type { SessionModule } from './wasm/session';
@@ -26,33 +26,31 @@ export type { UpdateContactNameResult, DeleteContactResult };
  * Get all contacts for an owner.
  *
  * @param ownerUserId - The user ID of the contact owner
- * @param db - Database instance
  * @returns Array of contacts
  *
  * @example
  * ```typescript
- * const contacts = await getContacts(myUserId, db);
+ * const contacts = await getContacts(myUserId);
  * contacts.forEach(c => console.log(c.name, c.userId));
  * ```
  */
-export declare function getContacts(ownerUserId: string, db: GossipDatabase): Promise<Contact[]>;
+export declare function getContacts(ownerUserId: string): Promise<Contact[]>;
 /**
  * Get a specific contact by owner and contact user IDs.
  *
  * @param ownerUserId - The user ID of the contact owner
  * @param contactUserId - The user ID of the contact
- * @param db - Database instance
  * @returns Contact or null if not found
  *
  * @example
  * ```typescript
- * const contact = await getContact(myUserId, theirUserId, db);
+ * const contact = await getContact(myUserId, theirUserId);
  * if (contact) {
  *   console.log('Found contact:', contact.name);
  * }
  * ```
  */
-export declare function getContact(ownerUserId: string, contactUserId: string, db: GossipDatabase): Promise<Contact | null>;
+export declare function getContact(ownerUserId: string, contactUserId: string): Promise<Contact | null>;
 /**
  * Add a new contact.
  *
@@ -60,7 +58,6 @@ export declare function getContact(ownerUserId: string, contactUserId: string, d
  * @param userId - The user ID of the contact (Bech32-encoded)
  * @param name - Display name for the contact
  * @param publicKeys - The contact's public keys
- * @param db - Database instance
  * @returns Result with success status and optional contact
  *
  * @example
@@ -69,8 +66,7 @@ export declare function getContact(ownerUserId: string, contactUserId: string, d
  *   myUserId,
  *   'gossip1abc...',
  *   'Alice',
- *   alicePublicKeys,
- *   db
+ *   alicePublicKeys
  * );
  * if (result.success) {
  *   console.log('Contact added:', result.contact?.name);
@@ -79,7 +75,7 @@ export declare function getContact(ownerUserId: string, contactUserId: string, d
  * }
  * ```
  */
-export declare function addContact(ownerUserId: string, userId: string, name: string, publicKeys: UserPublicKeys, db: GossipDatabase): Promise<{
+export declare function addContact(ownerUserId: string, userId: string, name: string, publicKeys: UserPublicKeys): Promise<{
     success: boolean;
     error?: string;
     contact?: Contact;
@@ -90,12 +86,11 @@ export declare function addContact(ownerUserId: string, userId: string, name: st
  * @param ownerUserId - The user ID of the contact owner
  * @param contactUserId - The user ID of the contact
  * @param newName - New name for the contact
- * @param db - Database instance
  * @returns Result with success status and trimmed name
  *
  * @example
  * ```typescript
- * const result = await updateContactName(myUserId, theirUserId, 'Alice Smith', db);
+ * const result = await updateContactName(myUserId, theirUserId, 'Alice Smith');
  * if (result.ok) {
  *   console.log('Updated to:', result.trimmedName);
  * } else {
@@ -103,19 +98,18 @@ export declare function addContact(ownerUserId: string, userId: string, name: st
  * }
  * ```
  */
-export declare function updateContactName(ownerUserId: string, contactUserId: string, newName: string, db: GossipDatabase): Promise<UpdateContactNameResult>;
+export declare function updateContactName(ownerUserId: string, contactUserId: string, newName: string): Promise<UpdateContactNameResult>;
 /**
  * Delete a contact and all associated discussions and messages.
  *
  * @param ownerUserId - The user ID of the contact owner
  * @param contactUserId - The user ID of the contact to delete
- * @param db - Database instance
  * @param session - Session module for peer management
  * @returns Result with success status
  *
  * @example
  * ```typescript
- * const result = await deleteContact(myUserId, theirUserId, db, session);
+ * const result = await deleteContact(myUserId, theirUserId, session);
  * if (result.ok) {
  *   console.log('Contact deleted');
  * } else {
@@ -123,4 +117,4 @@ export declare function updateContactName(ownerUserId: string, contactUserId: st
  * }
  * ```
  */
-export declare function deleteContact(ownerUserId: string, contactUserId: string, db: GossipDatabase, session: SessionModule): Promise<DeleteContactResult>;
+export declare function deleteContact(ownerUserId: string, contactUserId: string, session: SessionModule): Promise<DeleteContactResult>;

package/dist/contacts.js

@@ -18,22 +18,22 @@
  * ```
  */
 import { updateContactName as updateContactNameUtil, deleteContact as deleteContactUtil, } from './utils/contacts';
+import { getContactsByOwner, getContactByOwnerAndUser, insertContact as queryInsertContact, } from './queries';
 /**
  * Get all contacts for an owner.
  *
  * @param ownerUserId - The user ID of the contact owner
- * @param db - Database instance
  * @returns Array of contacts
  *
  * @example
  * ```typescript
- * const contacts = await getContacts(myUserId, db);
+ * const contacts = await getContacts(myUserId);
  * contacts.forEach(c => console.log(c.name, c.userId));
  * ```
  */
-export async function getContacts(ownerUserId, db) {
+export async function getContacts(ownerUserId) {
     try {
-        return await db.getContactsByOwner(ownerUserId);
+        return await getContactsByOwner(ownerUserId);
     }
     catch (error) {
         console.error('Error getting contacts:', error);
@@ -45,20 +45,19 @@ export async function getContacts(ownerUserId, db) {
  *
  * @param ownerUserId - The user ID of the contact owner
  * @param contactUserId - The user ID of the contact
- * @param db - Database instance
  * @returns Contact or null if not found
  *
  * @example
  * ```typescript
- * const contact = await getContact(myUserId, theirUserId, db);
+ * const contact = await getContact(myUserId, theirUserId);
  * if (contact) {
  *   console.log('Found contact:', contact.name);
  * }
  * ```
  */
-export async function getContact(ownerUserId, contactUserId, db) {
+export async function getContact(ownerUserId, contactUserId) {
     try {
-        const contact = await db.getContactByOwnerAndUserId(ownerUserId, contactUserId);
+        const contact = await getContactByOwnerAndUser(ownerUserId, contactUserId);
         return contact ?? null;
     }
     catch (error) {
@@ -73,7 +72,6 @@ export async function getContact(ownerUserId, contactUserId, db) {
  * @param userId - The user ID of the contact (Bech32-encoded)
  * @param name - Display name for the contact
  * @param publicKeys - The contact's public keys
- * @param db - Database instance
  * @returns Result with success status and optional contact
  *
  * @example
@@ -82,8 +80,7 @@ export async function getContact(ownerUserId, contactUserId, db) {
  *   myUserId,
  *   'gossip1abc...',
  *   'Alice',
- *   alicePublicKeys,
- *   db
+ *   alicePublicKeys
  * );
  * if (result.success) {
  *   console.log('Contact added:', result.contact?.name);
@@ -92,14 +89,14 @@ export async function getContact(ownerUserId, contactUserId, db) {
  * }
  * ```
  */
-export async function addContact(ownerUserId, userId, name, publicKeys, db) {
+export async function addContact(ownerUserId, userId, name, publicKeys) {
     try {
         // Check if contact already exists
-        const existing = await db.getContactByOwnerAndUserId(ownerUserId, userId);
+        const existing = await getContactByOwnerAndUser(ownerUserId, userId);
         if (existing) {
             return { success: false, error: 'Contact already exists' };
         }
-        const contact = {
+        await queryInsertContact({
             ownerUserId,
             userId,
             name,
@@ -107,10 +104,9 @@ export async function addContact(ownerUserId, userId, name, publicKeys, db) {
             isOnline: false,
             lastSeen: new Date(),
             createdAt: new Date(),
-        };
-        const id = await db.contacts.add(contact);
-        const newContact = await db.contacts.get(id);
-        return { success: true, contact: newContact };
+        });
+        const newContact = await getContactByOwnerAndUser(ownerUserId, userId);
+        return { success: true, contact: newContact ?? undefined };
     }
     catch (error) {
         console.error('Error adding contact:', error);
@@ -126,12 +122,11 @@ export async function addContact(ownerUserId, userId, name, publicKeys, db) {
  * @param ownerUserId - The user ID of the contact owner
  * @param contactUserId - The user ID of the contact
  * @param newName - New name for the contact
- * @param db - Database instance
  * @returns Result with success status and trimmed name
  *
  * @example
  * ```typescript
- * const result = await updateContactName(myUserId, theirUserId, 'Alice Smith', db);
+ * const result = await updateContactName(myUserId, theirUserId, 'Alice Smith');
  * if (result.ok) {
  *   console.log('Updated to:', result.trimmedName);
  * } else {
@@ -139,21 +134,20 @@ export async function addContact(ownerUserId, userId, name, publicKeys, db) {
  * }
  * ```
  */
-export async function updateContactName(ownerUserId, contactUserId, newName, db) {
-    return await updateContactNameUtil(ownerUserId, contactUserId, newName, db);
+export async function updateContactName(ownerUserId, contactUserId, newName) {
+    return await updateContactNameUtil(ownerUserId, contactUserId, newName);
 }
 /**
  * Delete a contact and all associated discussions and messages.
  *
  * @param ownerUserId - The user ID of the contact owner
  * @param contactUserId - The user ID of the contact to delete
- * @param db - Database instance
  * @param session - Session module for peer management
  * @returns Result with success status
  *
  * @example
  * ```typescript
- * const result = await deleteContact(myUserId, theirUserId, db, session);
+ * const result = await deleteContact(myUserId, theirUserId, session);
  * if (result.ok) {
  *   console.log('Contact deleted');
  * } else {
@@ -161,6 +155,6 @@ export async function updateContactName(ownerUserId, contactUserId, newName, db)
  * }
  * ```
  */
-export async function deleteContact(ownerUserId, contactUserId, db, session) {
-    return await deleteContactUtil(ownerUserId, contactUserId, db, session);
+export async function deleteContact(ownerUserId, contactUserId, session) {
+    return await deleteContactUtil(ownerUserId, contactUserId, session);
 }

package/dist/core/SdkEventEmitter.d.ts

@@ -7,6 +7,7 @@ import type { Message, Discussion, Contact } from '../db';
 export declare enum SdkEventType {
     MESSAGE_RECEIVED = "messageReceived",
     MESSAGE_SENT = "messageSent",
+    MESSAGE_READ = "messageRead",
     MESSAGE_FAILED = "messageFailed",
     SESSION_REQUESTED = "sessionRequested",
     SESSION_CREATED = "sessionCreated",
@@ -17,6 +18,7 @@ export declare enum SdkEventType {
 export interface SdkEventHandlers {
     [SdkEventType.MESSAGE_RECEIVED]: (message: Message) => void;
     [SdkEventType.MESSAGE_SENT]: (message: Message) => void;
+    [SdkEventType.MESSAGE_READ]: (messageId: number) => void;
     [SdkEventType.MESSAGE_FAILED]: (message: Message, error: Error) => void;
     [SdkEventType.SESSION_REQUESTED]: (discussion: Discussion, contact: Contact) => void;
     [SdkEventType.SESSION_CREATED]: (discussion: Discussion) => void;

package/dist/core/SdkEventEmitter.js

@@ -10,6 +10,7 @@ export var SdkEventType;
 (function (SdkEventType) {
     SdkEventType["MESSAGE_RECEIVED"] = "messageReceived";
     SdkEventType["MESSAGE_SENT"] = "messageSent";
+    SdkEventType["MESSAGE_READ"] = "messageRead";
     SdkEventType["MESSAGE_FAILED"] = "messageFailed";
     SdkEventType["SESSION_REQUESTED"] = "sessionRequested";
     SdkEventType["SESSION_CREATED"] = "sessionCreated";
@@ -29,6 +30,7 @@ export class SdkEventEmitter {
             value: {
                 [SdkEventType.MESSAGE_RECEIVED]: new Set(),
                 [SdkEventType.MESSAGE_SENT]: new Set(),
+                [SdkEventType.MESSAGE_READ]: new Set(),
                 [SdkEventType.MESSAGE_FAILED]: new Set(),
                 [SdkEventType.SESSION_REQUESTED]: new Set(),
                 [SdkEventType.SESSION_CREATED]: new Set(),

package/dist/core/SdkPolling.d.ts

@@ -4,17 +4,14 @@
  * Manages polling timers for messages, announcements, and session refresh.
  */
 import type { SdkConfig } from '../config/sdk';
-import type { Discussion } from '../db';
 import { SdkEventEmitter } from './SdkEventEmitter';
 export interface PollingCallbacks {
     /** Fetch messages from protocol */
     fetchMessages: () => Promise<void>;
     /** Fetch and process announcements */
     fetchAnnouncements: () => Promise<void>;
-    /** Handle session refresh for active discussions */
-    handleSessionRefresh: (discussions: Discussion[]) => Promise<void>;
-    /** Get active discussions for session refresh */
-    getActiveDiscussions: () => Promise<Discussion[]>;
+    /** Handle session refresh (state update) */
+    handleSessionRefresh: () => Promise<void>;
 }
 export declare class SdkPolling {
     private timers;

package/dist/core/SdkPolling.js

@@ -68,10 +68,7 @@ export class SdkPolling {
         // Start session refresh polling
         this.timers.sessionRefresh = setInterval(async () => {
             try {
-                const discussions = await this.callbacks?.getActiveDiscussions();
-                if (discussions && discussions.length > 0) {
-                    await this.callbacks?.handleSessionRefresh(discussions);
-                }
+                await this.callbacks?.handleSessionRefresh();
             }
             catch (error) {
                 const err = error instanceof Error ? error : new Error(String(error));

package/dist/core/index.d.ts

@@ -2,6 +2,6 @@
  * Core SDK components
  */
 export { SdkEventEmitter } from './SdkEventEmitter';
-export type { SdkEventType, SdkEventHandlers } from './SdkEventEmitter';
+export { SdkEventType, type SdkEventHandlers } from './SdkEventEmitter';
 export { SdkPolling } from './SdkPolling';
 export type { PollingCallbacks } from './SdkPolling';

package/dist/core/index.js

@@ -2,4 +2,5 @@
  * Core SDK components
  */
 export { SdkEventEmitter } from './SdkEventEmitter';
+export { SdkEventType } from './SdkEventEmitter';
 export { SdkPolling } from './SdkPolling';