@attrove/sdk 0.1.12 → 0.1.14

package/README.md

@@ -41,6 +41,9 @@ Ask questions about the user's unified context with AI-generated answers.
 // Simple query
 const response = await attrove.query('What did Sarah say about the Q4 budget?');
 console.log(response.answer);
+console.log(response.used_message_ids); // msg_xxx IDs
+console.log(response.used_meeting_ids); // mtg_xxx IDs
+console.log(response.used_event_ids);   // evt_xxx IDs
 
 // Multi-turn conversation - pass history from previous response
 let history = response.history;
@@ -50,14 +53,14 @@ history = followUp.history;
 
 // With filters
 const filtered = await attrove.query('Latest updates', {
-  integrationIds: ['integration-uuid'],  // Only search specific integration
+  integrationIds: ['int_xxx'],           // Only search specific integration
   includeSources: true                   // Include source snippets
 });
 ```
 
 ### `search(query, options?)`
 
-Semantic search that returns raw messages without AI summarization.
+Semantic search that returns raw matches across messages, meetings, and events without AI summarization.
 
 ```typescript
 const results = await attrove.search('product launch', {

package/cjs/constants.js

@@ -13,7 +13,7 @@ exports.getWsCloseReason = exports.WS_CLOSE_CODES = exports.RETRYABLE_STATUS_SET
  * Automatically synchronized with package.json during the release process.
  * For programmatic access, use `getVersion()` from './version'.
  */
-exports.SDK_VERSION = "0.1.12"; // auto-synced from package.json during release
+exports.SDK_VERSION = "0.1.14"; // auto-synced from package.json during release
 /**
  * Default API base URL for Attrove services.
  */

package/cjs/resources/messages.js

@@ -65,6 +65,9 @@ class MessagesResource {
         if (options.offset !== undefined) {
             params.offset = String(options.offset);
         }
+        if (options.excludeBots !== undefined) {
+            params.exclude_bots = String(options.excludeBots);
+        }
         if (options.expand?.length) {
             params.expand = options.expand.join(",");
         }

package/cjs/resources/query.js

@@ -6,6 +6,146 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.QueryResource = void 0;
+function normalizeOptionalId(value) {
+    return value == null ? null : String(value);
+}
+function normalizeRequiredId(value) {
+    return String(value);
+}
+function normalizeKeyMessage(message) {
+    return {
+        message_id: normalizeRequiredId(message.message_id),
+        thread_id: normalizeOptionalId(message.thread_id),
+        conversation_id: normalizeOptionalId(message.conversation_id),
+    };
+}
+function normalizeThreadMessage(message) {
+    return {
+        message_id: normalizeRequiredId(message.message_id),
+        received_at: message.received_at,
+        integration_type: normalizeIntegrationType(message.integration_type),
+        integration_type_generic: message.integration_type_generic,
+        sender_name: message.sender_name,
+        recipient_names: message.recipient_names,
+        body_text: message.body_text,
+        thread_id: normalizeOptionalId(message.thread_id),
+        thread_message_count: message.thread_message_count,
+        thread_position: message.thread_position,
+        parent_message_id: normalizeOptionalId(message.parent_message_id),
+        conversation_type: message.conversation_type,
+        conversation_id: normalizeOptionalId(message.conversation_id),
+        conversation_participants: message.conversation_participants,
+    };
+}
+const VALID_MEETING_PROVIDERS = new Set([
+    'google_meet',
+    'zoom',
+    'teams',
+    'unknown',
+]);
+function normalizeMeetingProvider(provider) {
+    if (VALID_MEETING_PROVIDERS.has(provider)) {
+        return provider;
+    }
+    // prettier-ignore
+    console.warn(`[Attrove SDK] Unknown meeting provider "${provider}" normalized to "unknown". SDK may need updating.`);
+    return 'unknown';
+}
+const VALID_INTEGRATION_TYPES = new Set([
+    'slack',
+    'gmail',
+    'outlook',
+    'google_calendar',
+    'outlook_calendar',
+    'unknown',
+]);
+function normalizeIntegrationType(type) {
+    if (VALID_INTEGRATION_TYPES.has(type)) {
+        return type;
+    }
+    // prettier-ignore
+    console.warn(`[Attrove SDK] Unknown integration type "${type}" normalized to "unknown". SDK may need updating.`);
+    return 'unknown';
+}
+function normalizeSearchMeeting(meeting) {
+    return {
+        id: meeting.id,
+        title: meeting.title,
+        meeting_code: meeting.meeting_code,
+        start_time: meeting.start_time,
+        end_time: meeting.end_time,
+        summary: meeting.summary,
+        short_summary: meeting.short_summary,
+        action_items: meeting.action_items,
+        attendees: meeting.attendees,
+        meeting_link: meeting.meeting_link,
+        has_transcript: meeting.has_transcript,
+        provider: normalizeMeetingProvider(meeting.provider),
+        event_id: meeting.event_id,
+        created_at: meeting.created_at,
+        updated_at: meeting.updated_at,
+    };
+}
+function normalizeSearchEvent(event) {
+    let attendees;
+    if (Array.isArray(event.attendees)) {
+        attendees = event.attendees;
+    }
+    else if (event.attendees !== undefined && event.attendees !== null) {
+        // prettier-ignore
+        console.warn(`[Attrove SDK] Event ${event.id} has non-array attendees (${typeof event.attendees}), ignoring.`);
+    }
+    return {
+        id: event.id,
+        calendar_id: event.calendar_id,
+        title: event.title,
+        description: event.description,
+        start_time: event.start_time,
+        end_time: event.end_time,
+        location: event.location,
+        status: event.status,
+        all_day: event.all_day,
+        organizer_entity_id: event.organizer_entity_id,
+        attendee_entity_ids: event.attendee_entity_ids,
+        attendees,
+        html_link: event.html_link,
+        event_link: event.event_link,
+        created_at: event.created_at,
+        updated_at: event.updated_at,
+    };
+}
+function normalizeSearchResponse(response) {
+    const conversations = response.conversations || {};
+    if (!response.conversations) {
+        // prettier-ignore
+        console.warn('[Attrove SDK] Search response missing conversations field, defaulting to empty object.');
+    }
+    const normalizedConversations = {};
+    for (const [conversationId, conversation] of Object.entries(conversations)) {
+        const normalizedThreads = {};
+        for (const [threadId, messages] of Object.entries(conversation.threads || {})) {
+            normalizedThreads[threadId] = (messages || []).map(normalizeThreadMessage);
+        }
+        normalizedConversations[conversationId] = {
+            conversation_name: conversation.conversation_name,
+            threads: normalizedThreads,
+        };
+    }
+    if (!response.key_messages) {
+        // prettier-ignore
+        console.warn('[Attrove SDK] Search response missing key_messages field, defaulting to empty array.');
+    }
+    const result = {
+        key_messages: (response.key_messages || []).map(normalizeKeyMessage),
+        conversations: normalizedConversations,
+        key_meetings: (response.key_meetings || []).map(normalizeSearchMeeting),
+        key_events: (response.key_events || []).map(normalizeSearchEvent),
+    };
+    if (response.warnings && response.warnings.length > 0) {
+        result.warnings = response.warnings;
+    }
+    return result;
+}
 /**
  * Query resource for RAG operations.
  *
@@ -48,7 +188,7 @@ class QueryResource {
      *
      * // With filters
      * const response = await attrove.query('Latest updates', {
-     *   integrationIds: ['550e8400-e29b-41d4-a716-446655440000'],
+     *   integrationIds: ['int_xxx'],
      *   includeSources: true
      * });
      * ```
@@ -71,25 +211,31 @@ class QueryResource {
             body.allow_bot_messages = options.allowBotMessages;
         }
         if (options.includeSources) {
-            body.expand = "sources";
+            body.expand = 'sources';
         }
-        const response = await this.http.post(`/v1/users/${this.userId}/query`, body);
+        const config = options.idempotencyKey
+            ? { headers: { "Idempotency-Key": options.idempotencyKey } }
+            : undefined;
+        const response = await this.http.post(`/v1/users/${this.userId}/query`, body, config);
         return {
             answer: response.answer,
             history: response.history,
             used_message_ids: response.used_message_ids,
+            used_meeting_ids: response.used_meeting_ids ?? [],
+            used_event_ids: response.used_event_ids ?? [],
             sources: response.sources,
         };
     }
     /**
      * Semantic search across the user's context.
      *
-     * Returns raw matching messages grouped by conversation, without AI summarization.
-     * Use this when you need full control over how results are displayed.
+     * Returns raw matching messages (grouped by conversation), plus matched meetings
+     * and calendar events, without AI summarization.
+     * Use this when you need full control over how results are displayed and processed.
      *
      * @param query - The search query (semantic, not keyword-based)
      * @param options - Search options including filters, date range, etc.
-     * @returns Matching messages grouped by conversation
+     * @returns Matching messages grouped by conversation, plus matched meetings and calendar events
      *
      * @throws {AuthenticationError} If the API key is invalid or expired
      * @throws {ValidationError} If the search parameters are invalid
@@ -108,10 +254,16 @@ class QueryResource {
      *   senderDomains: ['acme.com'],
      *   includeBodyText: true
      * });
+     *
+     * // Expand meeting and event detail fields
+     * const richResults = await attrove.search('standup action items', {
+     *   expand: ['summary', 'action_items', 'description']
+     * });
      * ```
      */
     async search(query, options = {}) {
         const body = { query };
+        const expandFields = new Set(options.expand || []);
         if (options.integrationIds?.length) {
             body.integration_ids = options.integrationIds;
         }
@@ -134,9 +286,16 @@ class QueryResource {
             body.entity_ids = options.entityIds;
         }
         if (options.includeBodyText) {
-            body.expand = "body_text";
+            expandFields.add('body_text');
+        }
+        if (expandFields.size > 0) {
+            body.expand = Array.from(expandFields).join(',');
         }
-        return this.http.post(`/v1/users/${this.userId}/search`, body);
+        const config = options.idempotencyKey
+            ? { headers: { "Idempotency-Key": options.idempotencyKey } }
+            : undefined;
+        const response = await this.http.post(`/v1/users/${this.userId}/search`, body, config);
+        return normalizeSearchResponse(response);
     }
 }
 exports.QueryResource = QueryResource;

package/cjs/resources/settings.js

@@ -27,6 +27,27 @@ class AdminSettingsResource {
         this.http = http;
         this.clientId = clientId;
     }
+    /**
+     * Get current organization sync settings.
+     *
+     * @returns Current settings
+     *
+     * @throws {AuthenticationError} If partner credentials are invalid
+     * @throws {NetworkError} If unable to reach the API
+     *
+     * @example
+     * ```ts
+     * const admin = Attrove.admin({ clientId, clientSecret });
+     * const settings = await admin.settings.get();
+     * console.log(settings.initialSyncDays); // 30 or null
+     * ```
+     */
+    async get() {
+        const raw = await this.http.get('/v1/users/settings');
+        return {
+            initialSyncDays: raw.initial_sync_days,
+        };
+    }
     /**
      * Update organization sync settings.
      *
@@ -37,32 +58,27 @@ class AdminSettingsResource {
      * @param options - Settings to update
      * @returns Current settings after the update
      *
-     * @throws {ValidationError} If the options are invalid (e.g., initialSyncDays out of range)
+     * @throws {ValidationError} If initialSyncDays is out of range (7-90) or not an integer
      * @throws {AuthenticationError} If partner credentials are invalid
      * @throws {NetworkError} If unable to reach the API
      *
      * @example
      * ```ts
      * const admin = Attrove.admin({ clientId, clientSecret });
-     *
-     * // Set initial sync depth to 14 days
      * const settings = await admin.settings.update({ initialSyncDays: 14 });
      * console.log(settings.initialSyncDays); // 14
      * ```
      */
     async update(options) {
-        if (options.initialSyncDays !== undefined) {
-            if (!Number.isInteger(options.initialSyncDays) ||
-                options.initialSyncDays < MIN_SYNC_DAYS ||
-                options.initialSyncDays > MAX_SYNC_DAYS) {
-                throw new index_js_1.ValidationError(`initialSyncDays must be an integer between ${MIN_SYNC_DAYS} and ${MAX_SYNC_DAYS}, got ${options.initialSyncDays}`);
-            }
+        if (!Number.isInteger(options.initialSyncDays) ||
+            options.initialSyncDays < MIN_SYNC_DAYS ||
+            options.initialSyncDays > MAX_SYNC_DAYS) {
+            throw new index_js_1.ValidationError(`initialSyncDays must be an integer between ${MIN_SYNC_DAYS} and ${MAX_SYNC_DAYS}, got ${options.initialSyncDays}`);
         }
-        const body = { client_id: this.clientId };
-        if (options.initialSyncDays !== undefined) {
-            body.initial_sync_days = options.initialSyncDays;
-        }
-        const raw = await this.http.patch("/v1/users/settings", body);
+        const body = {
+            initial_sync_days: options.initialSyncDays,
+        };
+        const raw = await this.http.patch('/v1/users/settings', body);
         return {
             initialSyncDays: raw.initial_sync_days,
         };

package/cjs/types/index.js

@@ -79,11 +79,11 @@ exports.isValidUUID = isValidUUID;
  * ```
  */
 function createUserId(value) {
-    if (!value || typeof value !== "string") {
-        return { success: false, error: "UserId must be a non-empty string" };
+    if (!value || typeof value !== 'string') {
+        return { success: false, error: 'UserId must be a non-empty string' };
     }
     if (!UUID_REGEX.test(value)) {
-        return { success: false, error: "UserId must be a valid UUID format" };
+        return { success: false, error: 'UserId must be a valid UUID format' };
     }
     return { success: true, value: value };
 }
@@ -92,16 +92,16 @@ exports.createUserId = createUserId;
  * Validate and create an IntegrationId from a string.
  */
 function createIntegrationId(value) {
-    if (!value || typeof value !== "string") {
+    if (!value || typeof value !== 'string') {
         return {
             success: false,
-            error: "IntegrationId must be a non-empty string",
+            error: 'IntegrationId must be a non-empty string',
         };
     }
     if (!UUID_REGEX.test(value)) {
         return {
             success: false,
-            error: "IntegrationId must be a valid UUID format",
+            error: 'IntegrationId must be a valid UUID format',
         };
     }
     return { success: true, value: value };
@@ -111,11 +111,11 @@ exports.createIntegrationId = createIntegrationId;
  * Validate and create a MessageId from a string.
  */
 function createMessageId(value) {
-    if (!value || typeof value !== "string") {
-        return { success: false, error: "MessageId must be a non-empty string" };
+    if (!value || typeof value !== 'string') {
+        return { success: false, error: 'MessageId must be a non-empty string' };
     }
     if (!UUID_REGEX.test(value)) {
-        return { success: false, error: "MessageId must be a valid UUID format" };
+        return { success: false, error: 'MessageId must be a valid UUID format' };
     }
     return { success: true, value: value };
 }
@@ -124,16 +124,16 @@ exports.createMessageId = createMessageId;
  * Validate and create a ConversationId from a string.
  */
 function createConversationId(value) {
-    if (!value || typeof value !== "string") {
+    if (!value || typeof value !== 'string') {
         return {
             success: false,
-            error: "ConversationId must be a non-empty string",
+            error: 'ConversationId must be a non-empty string',
         };
     }
     if (!UUID_REGEX.test(value)) {
         return {
             success: false,
-            error: "ConversationId must be a valid UUID format",
+            error: 'ConversationId must be a valid UUID format',
         };
     }
     return { success: true, value: value };
@@ -151,8 +151,8 @@ exports.createConversationId = createConversationId;
  * ```
  */
 function createApiKey(value) {
-    if (!value || typeof value !== "string") {
-        return { success: false, error: "ApiKey must be a non-empty string" };
+    if (!value || typeof value !== 'string') {
+        return { success: false, error: 'ApiKey must be a non-empty string' };
     }
     if (!API_KEY_REGEX.test(value)) {
         return {
@@ -175,22 +175,22 @@ exports.createApiKey = createApiKey;
  * ```
  */
 function createISODate(value) {
-    if (!value || typeof value !== "string") {
+    if (!value || typeof value !== 'string') {
         return {
             success: false,
-            error: "ISODateString must be a non-empty string",
+            error: 'ISODateString must be a non-empty string',
         };
     }
     if (!ISO_DATE_REGEX.test(value)) {
         return {
             success: false,
-            error: "ISODateString must be a valid ISO 8601 date format",
+            error: 'ISODateString must be a valid ISO 8601 date format',
         };
     }
     // Additional validation: ensure it parses to a valid date
     const parsed = Date.parse(value);
     if (Number.isNaN(parsed)) {
-        return { success: false, error: "ISODateString must be a valid date" };
+        return { success: false, error: 'ISODateString must be a valid date' };
     }
     return { success: true, value: value };
 }
@@ -199,11 +199,11 @@ exports.createISODate = createISODate;
  * Validate and create a UUID from a string.
  */
 function createUUID(value) {
-    if (!value || typeof value !== "string") {
-        return { success: false, error: "UUID must be a non-empty string" };
+    if (!value || typeof value !== 'string') {
+        return { success: false, error: 'UUID must be a non-empty string' };
     }
     if (!UUID_REGEX.test(value)) {
-        return { success: false, error: "UUID must be a valid UUID format" };
+        return { success: false, error: 'UUID must be a valid UUID format' };
     }
     return { success: true, value: value };
 }
@@ -217,7 +217,7 @@ exports.createUUID = createUUID;
  * @see {@link isApiKey} for a type guard that narrows to ApiKeyFormat
  */
 function isValidApiKey(value) {
-    return typeof value === "string" && API_KEY_REGEX.test(value);
+    return typeof value === 'string' && API_KEY_REGEX.test(value);
 }
 exports.isValidApiKey = isValidApiKey;
 /**
@@ -244,7 +244,7 @@ exports.isValidApiKey = isValidApiKey;
  * @see {@link isValidApiKey} for a simple boolean check without type narrowing
  */
 function isApiKey(value) {
-    return typeof value === "string" && API_KEY_REGEX.test(value);
+    return typeof value === 'string' && API_KEY_REGEX.test(value);
 }
 exports.isApiKey = isApiKey;
 /**
@@ -262,44 +262,44 @@ exports.isValidISODate = isValidISODate;
  */
 exports.ErrorCodes = {
     // Authentication errors
-    AUTH_MISSING_TOKEN: "AUTH_MISSING_TOKEN",
-    AUTH_INVALID_TOKEN: "AUTH_INVALID_TOKEN",
-    AUTH_EXPIRED_TOKEN: "AUTH_EXPIRED_TOKEN",
-    AUTH_USER_MISMATCH: "AUTH_USER_MISMATCH",
-    AUTH_INSUFFICIENT_PERMISSIONS: "AUTH_INSUFFICIENT_PERMISSIONS",
+    AUTH_MISSING_TOKEN: 'AUTH_MISSING_TOKEN',
+    AUTH_INVALID_TOKEN: 'AUTH_INVALID_TOKEN',
+    AUTH_EXPIRED_TOKEN: 'AUTH_EXPIRED_TOKEN',
+    AUTH_USER_MISMATCH: 'AUTH_USER_MISMATCH',
+    AUTH_INSUFFICIENT_PERMISSIONS: 'AUTH_INSUFFICIENT_PERMISSIONS',
     // Resource errors
-    RESOURCE_NOT_FOUND: "RESOURCE_NOT_FOUND",
-    RESOURCE_ACCESS_DENIED: "RESOURCE_ACCESS_DENIED",
-    RESOURCE_ALREADY_EXISTS: "RESOURCE_ALREADY_EXISTS",
-    RESOURCE_DELETED: "RESOURCE_DELETED",
+    RESOURCE_NOT_FOUND: 'RESOURCE_NOT_FOUND',
+    RESOURCE_ACCESS_DENIED: 'RESOURCE_ACCESS_DENIED',
+    RESOURCE_ALREADY_EXISTS: 'RESOURCE_ALREADY_EXISTS',
+    RESOURCE_DELETED: 'RESOURCE_DELETED',
     // Validation errors
-    VALIDATION_INVALID_ID: "VALIDATION_INVALID_ID",
-    VALIDATION_REQUIRED_FIELD: "VALIDATION_REQUIRED_FIELD",
-    VALIDATION_INVALID_FORMAT: "VALIDATION_INVALID_FORMAT",
-    VALIDATION_OUT_OF_RANGE: "VALIDATION_OUT_OF_RANGE",
+    VALIDATION_INVALID_ID: 'VALIDATION_INVALID_ID',
+    VALIDATION_REQUIRED_FIELD: 'VALIDATION_REQUIRED_FIELD',
+    VALIDATION_INVALID_FORMAT: 'VALIDATION_INVALID_FORMAT',
+    VALIDATION_OUT_OF_RANGE: 'VALIDATION_OUT_OF_RANGE',
     // Integration errors
-    INTEGRATION_OAUTH_FAILED: "INTEGRATION_OAUTH_FAILED",
-    INTEGRATION_EMAIL_EXISTS: "INTEGRATION_EMAIL_EXISTS",
-    INTEGRATION_TOKEN_EXPIRED: "INTEGRATION_TOKEN_EXPIRED",
-    INTEGRATION_SYNC_FAILED: "INTEGRATION_SYNC_FAILED",
-    INTEGRATION_NOT_CONNECTED: "INTEGRATION_NOT_CONNECTED",
+    INTEGRATION_OAUTH_FAILED: 'INTEGRATION_OAUTH_FAILED',
+    INTEGRATION_EMAIL_EXISTS: 'INTEGRATION_EMAIL_EXISTS',
+    INTEGRATION_TOKEN_EXPIRED: 'INTEGRATION_TOKEN_EXPIRED',
+    INTEGRATION_SYNC_FAILED: 'INTEGRATION_SYNC_FAILED',
+    INTEGRATION_NOT_CONNECTED: 'INTEGRATION_NOT_CONNECTED',
     // Rate limiting
-    RATE_LIMIT_EXCEEDED: "RATE_LIMIT_EXCEEDED",
+    RATE_LIMIT_EXCEEDED: 'RATE_LIMIT_EXCEEDED',
     // Server errors
-    INTERNAL_ERROR: "INTERNAL_ERROR",
-    SERVICE_UNAVAILABLE: "SERVICE_UNAVAILABLE",
-    REQUEST_TIMEOUT: "REQUEST_TIMEOUT",
+    INTERNAL_ERROR: 'INTERNAL_ERROR',
+    SERVICE_UNAVAILABLE: 'SERVICE_UNAVAILABLE',
+    REQUEST_TIMEOUT: 'REQUEST_TIMEOUT',
 };
 /**
  * Valid stream frame types.
  */
 const VALID_FRAME_TYPES = new Set([
-    "chunk",
-    "end",
-    "error",
-    "state",
-    "message_ids",
-    "stream_start",
+    'chunk',
+    'end',
+    'error',
+    'state',
+    'message_ids',
+    'stream_start',
 ]);
 /**
  * Runtime validator for StreamFrame objects.
@@ -318,35 +318,46 @@ const VALID_FRAME_TYPES = new Set([
  * ```
  */
 function isValidStreamFrame(data) {
-    if (!data || typeof data !== "object") {
+    if (!data || typeof data !== 'object') {
         return false;
     }
     const frame = data;
     // All frames must have type and message_id
-    if (typeof frame.type !== "string" || !VALID_FRAME_TYPES.has(frame.type)) {
+    if (typeof frame.type !== 'string' || !VALID_FRAME_TYPES.has(frame.type)) {
         return false;
     }
-    if (typeof frame.message_id !== "string") {
+    if (typeof frame.message_id !== 'string') {
         return false;
     }
     // Type-specific validation
     switch (frame.type) {
-        case "chunk":
-            return typeof frame.content === "string";
-        case "end":
-            return (typeof frame.reason === "string" &&
-                ["completed", "cancelled", "error"].includes(frame.reason));
-        case "error":
-            return typeof frame.error === "string";
-        case "state":
-            return typeof frame.state === "string";
-        case "message_ids":
+        case 'chunk':
+            return typeof frame.content === 'string';
+        case 'end':
+            return (typeof frame.reason === 'string' &&
+                ['completed', 'cancelled', 'error'].includes(frame.reason) &&
+                isOptionalStringArray(frame.used_message_ids) &&
+                isOptionalStringArray(frame.used_meeting_ids) &&
+                isOptionalStringArray(frame.used_event_ids));
+        case 'error':
+            return typeof frame.error === 'string';
+        case 'state':
+            return typeof frame.state === 'string';
+        case 'message_ids':
             return (Array.isArray(frame.used_message_ids) &&
-                frame.used_message_ids.every((id) => typeof id === "string"));
-        case "stream_start":
+                frame.used_message_ids.every((id) => typeof id === 'string') &&
+                isOptionalStringArray(frame.used_meeting_ids) &&
+                isOptionalStringArray(frame.used_event_ids));
+        case 'stream_start':
             return true;
         default:
             return false;
     }
 }
 exports.isValidStreamFrame = isValidStreamFrame;
+function isOptionalStringArray(value) {
+    if (value === undefined)
+        return true;
+    return (Array.isArray(value) &&
+        value.every((item) => typeof item === 'string'));
+}

package/cjs/utils/streaming.js

@@ -108,6 +108,8 @@ class StreamingClient {
         this.onWarning = onWarning;
         let answer = "";
         let usedMessageIds = [];
+        let usedMeetingIds = [];
+        let usedEventIds = [];
         let cancelled = false;
         let completed = false;
         // Connect to WebSocket
@@ -225,6 +227,12 @@ class StreamingClient {
                         break;
                     case "message_ids":
                         usedMessageIds = frame.used_message_ids;
+                        if (frame.used_meeting_ids !== undefined) {
+                            usedMeetingIds = frame.used_meeting_ids;
+                        }
+                        if (frame.used_event_ids !== undefined) {
+                            usedEventIds = frame.used_event_ids;
+                        }
                         break;
                     case "error": {
                         const error = new index_js_2.AttroveError(frame.error, index_js_3.ErrorCodes.INTERNAL_ERROR);
@@ -238,6 +246,12 @@ class StreamingClient {
                         if (frame.used_message_ids) {
                             usedMessageIds = frame.used_message_ids;
                         }
+                        if (frame.used_meeting_ids !== undefined) {
+                            usedMeetingIds = frame.used_meeting_ids;
+                        }
+                        if (frame.used_event_ids !== undefined) {
+                            usedEventIds = frame.used_event_ids;
+                        }
                         onEnd?.(frame.reason);
                         // Build updated history
                         const updatedHistory = [
@@ -249,6 +263,8 @@ class StreamingClient {
                             answer,
                             history: updatedHistory,
                             usedMessageIds,
+                            usedMeetingIds,
+                            usedEventIds,
                             cancelled,
                         });
                         break;