@unboundcx/sdk 4.0.10 → 4.0.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unboundcx/sdk",
-  "version": "4.0.10",
+  "version": "4.0.12",
   "description": "Official JavaScript SDK for the Unbound API - A comprehensive toolkit for integrating with Unbound's communication, AI, and data management services",
   "main": "index.js",
   "type": "module",

package/proto/transcription.proto

@@ -28,7 +28,7 @@ message AudioRequest {
   string language = 4;
 
   // Transcription engine to use
-  // Options: "whisper", "google"
+  // Options: "whisper", "google", "groq"
   string engine = 5;
 
   // Audio configuration
@@ -66,28 +66,48 @@ message AudioRequest {
   // VAD event timestamp
   int64 vad_timestamp = 15;
 
-  // Playbook identifier (optional - links transcription to a playbook session)
+  // Optional playbook ID for real-time agent scoring
   string playbook_id = 16;
 
-  // Bridge identifier (optional - links related transcription streams)
-  // When multiple bridged call legs have transcription active,
-  // bridge_id lets the transcription service correlate them
+  // Bridge ID linking related transcription streams (e.g., both legs of a bridged call)
+  // Empty string = not part of any bridge. Dynamic: can appear, change, or disappear mid-stream.
   string bridge_id = 17;
 
-  // Task identifier (optional - links transcription to a specific task)
+  // Optional task ID for playbook session tracking
   string task_id = 18;
 
-  // Worker identifier (optional)
+  // Optional worker ID for playbook session tracking
   string worker_id = 19;
 
-  // Generate subject from transcription (optional)
+  // Enable real-time subject generation from customer transcripts
+  // Requires task_id to be set for SDK task update
   bool generate_subject = 20;
 
-  // Generate transcript summary (optional)
+  // Enable end-of-call transcript summary generation
+  // Requires task_id to be set for SDK task update
   bool generate_transcript_summary = 21;
 
-  // Generate sentiment analysis (optional)
+  // Enable real-time sentiment analysis with multi-signal fusion
+  // Requires task_id to be set for SDK task update
   bool generate_sentiment = 22;
+
+  // ── Meet (video-room) session metadata — additive, optional ──────────────
+  // Video room ID this stream belongs to (Meet sessions only). Also used as
+  // the conversation identifier for Meet sessions.
+  string video_room_id = 23;
+
+  // Video room participant ID (Meet sessions only)
+  string participant_id = 24;
+
+  // Display name of the participant (Meet sessions only)
+  string display_name = 25;
+
+  // Opt-in server-side VAD: when true, this repo runs its own energy-based
+  // silence detector over incoming PCM chunks and injects synthetic
+  // speaking_started/speaking_stopped vad_events (media-manager-parity
+  // SilenceDetector), instead of relying on client-sent vad_event fields.
+  // Defaults to false/unset: existing (non-Meet) callers are unaffected.
+  bool server_vad = 26;
 }
 
 // Audio configuration
@@ -156,6 +176,28 @@ message TranscriptResponse {
 
   // Speaker role (echoed back from AudioRequest)
   string role = 11;
+
+  // Sentiment score (-100 to +100, 0 if sentiment not enabled)
+  float sentiment_score = 12;
+
+  // Sentiment trend ('improving', 'stable', 'declining', empty if not enabled)
+  string sentiment_trend = 13;
+
+  // Unique message ID for correlating transcript with its sentiment update
+  string message_id = 14;
+
+  // Whether this message is a sentiment enrichment update (not a new transcript)
+  bool is_sentiment_update = 15;
+
+  // ── Meet (video-room) session metadata — additive, optional, echoed back ─
+  // Video room ID (echoed back from AudioRequest, Meet sessions only)
+  string video_room_id = 16;
+
+  // Video room participant ID (echoed back from AudioRequest, Meet sessions only)
+  string participant_id = 17;
+
+  // Display name of the participant (echoed back from AudioRequest, Meet sessions only)
+  string display_name = 18;
 }
 
 // Word-level information

package/services/ai/SttStream.js

@@ -118,6 +118,10 @@ export class SttStream extends EventEmitter {
     //   sipCallId: string,   // NEW
     //   side: string,        // NEW
     //   role: string         // NEW
+    //   videoRoomId: string,     // NEW (meet sessions only, else '')
+    //   participantId: string,   // NEW (meet sessions only, else '')
+    //   displayName: string,     // NEW (meet sessions only, else '')
+    //   messageId: string        // NEW (proto field 14)
     // }
 
     if (response.transcript) {
@@ -134,6 +138,11 @@ export class SttStream extends EventEmitter {
         sipCallId: response.sipCallId || response.sip_call_id || '',
         side: response.side || '',
         role: response.role || '',
+        // Meet (video-room) session metadata (NEW, additive, '' when not a meet session)
+        videoRoomId: response.videoRoomId || response.video_room_id || '',
+        participantId: response.participantId || response.participant_id || '',
+        displayName: response.displayName || response.display_name || '',
+        messageId: response.messageId || response.message_id || '',
       };
 
       this.emit('transcript', transcriptData);
@@ -154,6 +163,10 @@ export class SttStream extends EventEmitter {
    * @param {string} streamMetadata.role - Optional speaker role (e.g., 'customer', 'agent', 'system')
    * @param {boolean} streamMetadata.isLastChunk - If true, marks this specific stream as complete
    * @returns {boolean} - True if write successful
+   *
+   * Meet (video-room) session metadata is not per-chunk — it is sent once in the
+   * first-chunk session config, read from stream options: options.videoRoomId,
+   * options.participantId, options.displayName, options.serverVad. See constructor.
    */
   write(audioChunk, streamMetadata = {}) {
     if (this.isClosed) {
@@ -205,6 +218,11 @@ export class SttStream extends EventEmitter {
           generate_transcript_summary: this.options.generateTranscriptSummary || false,
           generate_sentiment: this.options.generateSentiment || false,
           bridge_id: bridgeId,
+          // Meet (video-room) session metadata (NEW, additive, optional)
+          video_room_id: this.options.videoRoomId || '',
+          participant_id: this.options.participantId || '',
+          display_name: this.options.displayName || '',
+          server_vad: this.options.serverVad || false,
         };
 
         this.grpcCall.write(request);

package/services/ai.js

@@ -224,6 +224,27 @@ export class GenerativeService {
     return result;
   }
 
+  /**
+   * Summarize chat/transcript content (running summary, chapters, title)
+   * @param {Object} payload
+   * @param {string} [payload.domain] - Summary domain (e.g. 'meeting')
+   * @param {string} [payload.mode] - Summary mode
+   * @param {Array} [payload.lines] - Transcript/chat lines to summarize
+   * @param {Array} [payload.chatMessages] - Chat messages to summarize
+   * @param {string} [payload.runningSummary] - Existing running summary to extend
+   * @param {boolean} [payload.includeChapters] - Include chapter breakdown
+   * @param {boolean} [payload.includeTitle] - Include a generated title
+   * @returns {Promise<Object>} Summary result
+   */
+  async summarize(payload = {}) {
+    const params = {
+      body: payload,
+    };
+
+    const result = await this.sdk._fetch('/ai/summarize', 'POST', params);
+    return result;
+  }
+
   /**
    * List available chat tools and their metadata
    * @returns {Promise<Object>} { tools: Array<{ name, label, description, configRequirements }>, count: number }
@@ -611,6 +632,11 @@ export class SpeechToTextService {
    * @param {string} [options.playbookId] - Playbook ID
    * @param {string} [options.name] - Session name
    * @param {Object} [options.metadata] - Additional metadata
+   * @param {string} [options.videoRoomId] - Video (Meet) room ID this stream belongs to
+   * @param {string} [options.videoParticipantId] - Video (Meet) room participant ID
+   * @param {string} [options.displayName] - Participant display name (Meet sessions)
+   * @param {string} [options.role] - Speaker role (e.g. 'participant', 'host')
+   * @param {boolean} [options.serverVad] - Opt-in server-side VAD (Meet sessions; defaults false)
    * @returns {Promise<SttStream>} Stream object with write() method and transcript events
    *
    * @example
@@ -658,6 +684,11 @@ export class SpeechToTextService {
       metadata,
       sipCallId,
       cdrId,
+      videoRoomId,
+      videoParticipantId,
+      displayName,
+      role,
+      serverVad,
     } = options;
 
     // Validate parameters
@@ -689,6 +720,11 @@ export class SpeechToTextService {
         metadata,
         sipCallId,
         cdrId,
+        videoRoomId,
+        videoParticipantId,
+        displayName,
+        role,
+        serverVad,
       },
       {
         engine: { type: 'string', required: false },
@@ -717,6 +753,11 @@ export class SpeechToTextService {
         metadata: { type: 'object', required: false },
         sipCallId: { type: 'string', required: false },
         cdrId: { type: 'string', required: false },
+        videoRoomId: { type: 'string', required: false },
+        videoParticipantId: { type: 'string', required: false },
+        displayName: { type: 'string', required: false },
+        role: { type: 'string', required: false },
+        serverVad: { type: 'boolean', required: false },
       },
     );
 
@@ -736,6 +777,10 @@ export class SpeechToTextService {
         sipCallId,
         cdrId,
         name,
+        videoRoomId,
+        videoParticipantId,
+        displayName,
+        role,
         metadata: {
           ...metadata,
           languageCode,
@@ -773,6 +818,12 @@ export class SpeechToTextService {
       vadEnabled,
       minSilenceDuration,
       speechPadMs,
+      // SttStream reads these as videoRoomId/participantId/displayName/serverVad
+      // for the gRPC first-chunk session config.
+      videoRoomId,
+      participantId: videoParticipantId,
+      displayName,
+      serverVad,
     };
 
     return new SttStream(this.sdk, session, streamOptions);
@@ -883,6 +934,8 @@ export class SpeechToTextService {
       side,
       bridgeId,
       sentiment,
+      videoRoomId,
+      videoParticipantId,
     },
   ) {
     this.sdk.validateParams(
@@ -902,6 +955,8 @@ export class SpeechToTextService {
         side: { type: 'string', required: false },
         bridgeId: { type: 'string', required: false },
         sentiment: { type: 'object', required: false },
+        videoRoomId: { type: 'string', required: false },
+        videoParticipantId: { type: 'string', required: false },
       },
     );
 
@@ -920,6 +975,8 @@ export class SpeechToTextService {
         side,
         bridgeId,
         sentiment,
+        videoRoomId,
+        videoParticipantId,
       },
     };
 

package/services/googleCalendar.js

@@ -3,19 +3,38 @@ export class GoogleCalendarService {
     this.sdk = sdk;
   }
 
-  async setupWebhook({ calendarId, eventTypes, webhookUrl, expirationTime }) {
+  async setupWebhook({
+    calendarId,
+    eventTypes,
+    webhookUrl,
+    expirationTime,
+    recordTypeId,
+  } = {}) {
+    // Only calendarId is required. The server derives the webhook URL itself
+    // (per-environment: https://login.<API_BASE_URL>/webhooks/google/...) and
+    // watches all event types, so eventTypes/webhookUrl are optional. They
+    // were previously marked required, which broke the common
+    // setupWebhook({ calendarId }) call site (createRoom) with
+    // "Missing required parameter eventTypes".
+    // recordTypeId is optional: callers (e.g. createRoom) pass the meeting's
+    // already-resolved recordTypeId so the webhook row inherits it; if omitted
+    // the server resolves a fallback via findRecordTypeId.
     this.sdk.validateParams(
-      { calendarId, eventTypes, webhookUrl },
+      { calendarId, eventTypes, webhookUrl, recordTypeId },
       {
         calendarId: { type: 'string', required: true },
-        eventTypes: { type: 'array', required: true },
-        webhookUrl: { type: 'string', required: true },
+        eventTypes: { type: 'array', required: false },
+        webhookUrl: { type: 'string', required: false },
         expirationTime: { type: 'number', required: false },
+        recordTypeId: { type: 'string', required: false },
       },
     );
 
-    const webhookData = { calendarId, eventTypes, webhookUrl };
+    const webhookData = { calendarId };
+    if (eventTypes) webhookData.eventTypes = eventTypes;
+    if (webhookUrl) webhookData.webhookUrl = webhookUrl;
     if (expirationTime) webhookData.expirationTime = expirationTime;
+    if (recordTypeId) webhookData.recordTypeId = recordTypeId;
 
     const params = {
       body: webhookData,

package/services/video.js

@@ -221,6 +221,13 @@ export class VideoService {
     startMicrophoneMutedAfter,
     enableChat,
     engagementSessionId,
+    startRecordingOn,
+    startTranscribingOn,
+    syncToCalendar,
+    source,
+    calendarId,
+    eventId,
+    calendarProvider,
   }) {
     this.sdk.validateParams(
       {
@@ -241,6 +248,13 @@ export class VideoService {
         startMicrophoneMutedAfter,
         enableChat,
         engagementSessionId,
+        startRecordingOn,
+        startTranscribingOn,
+        syncToCalendar,
+        source,
+        calendarId,
+        eventId,
+        calendarProvider,
       },
       {
         name: { type: 'string', required: false },
@@ -260,6 +274,13 @@ export class VideoService {
         startMicrophoneMutedAfter: { type: 'number', required: false },
         enableChat: { type: 'boolean', required: false },
         engagementSessionId: { type: 'string', required: false },
+        startRecordingOn: { type: 'boolean', required: false },
+        startTranscribingOn: { type: 'boolean', required: false },
+        syncToCalendar: { type: 'boolean', required: false },
+        source: { type: 'string', required: false },
+        calendarId: { type: 'string', required: false },
+        eventId: { type: 'string', required: false },
+        calendarProvider: { type: 'string', required: false },
       },
     );
     const params = {
@@ -281,6 +302,13 @@ export class VideoService {
         startMicrophoneMutedAfter,
         enableChat,
         engagementSessionId,
+        startRecordingOn,
+        startTranscribingOn,
+        syncToCalendar,
+        source,
+        calendarId,
+        eventId,
+        calendarProvider,
       },
     };
     const result = await this.sdk._fetch(`/video`, 'POST', params);
@@ -459,7 +487,7 @@ export class VideoService {
     return result;
   }
 
-  async deleteRoom(roomId) {
+  async deleteRoom(roomId, options = {}) {
     this.sdk.validateParams(
       { roomId },
       {
@@ -467,6 +495,9 @@ export class VideoService {
       },
     );
     const params = {};
+    if (options && options.deleteCalendarEvent === true) {
+      params.body = { deleteCalendarEvent: true };
+    }
     const result = await this.sdk._fetch(`/video/${roomId}`, 'DELETE', params);
     return result;
   }
@@ -618,6 +649,26 @@ export class VideoService {
     return result;
   }
 
+  // Persist a rolled-up quality summary to MySQL (one row per participant
+  // per meeting). Internal endpoint, called by app1-video-server on
+  // participant.leave. Long-term home for billing (bytes) and "was this
+  // meeting good?" support lookups, surviving ClickHouse TTL expiry.
+  async submitParticipantSummary(roomId, participantId, summary) {
+    this.sdk.validateParams(
+      { roomId, participantId, summary },
+      {
+        roomId: { type: 'string', required: true },
+        participantId: { type: 'string', required: true },
+        summary: { type: 'object', required: true },
+      },
+    );
+    return this.sdk._fetch(
+      `/internal/video/${roomId}/participants/${participantId}/summary`,
+      'POST',
+      { body: summary },
+    );
+  }
+
   async submitSurvey({
     videoRoomId,
     participantId,
@@ -749,6 +800,42 @@ export class VideoService {
     return result;
   }
 
+  /**
+   * Get the live transcription transcript for a video room, paged.
+   * @param {string} roomId - The video room ID
+   * @param {Object} [options] - Paging options
+   * @param {number} [options.limit] - Max rows to return
+   * @param {number} [options.offset] - Row offset
+   * @returns {Promise} Paged transcript rows, ordered by timestamp/createdAt ascending
+   */
+  async getTranscript(roomId, options = {}) {
+    this.sdk.validateParams(
+      { roomId },
+      {
+        roomId: { type: 'string', required: true },
+      },
+    );
+
+    const validationSchema = {};
+    if ('limit' in options) validationSchema.limit = { type: 'number' };
+    if ('offset' in options) validationSchema.offset = { type: 'number' };
+
+    if (Object.keys(validationSchema).length > 0) {
+      this.sdk.validateParams(options, validationSchema);
+    }
+
+    const params = {
+      query: options,
+    };
+
+    const result = await this.sdk._fetch(
+      `/video/${roomId}/transcript`,
+      'GET',
+      params,
+    );
+    return result;
+  }
+
   /**
    * Edit a chat message in a video room
    * Only the participant who created the message can edit it
@@ -943,4 +1030,182 @@ export class VideoService {
     const result = await this.sdk._fetch('/video/settings/user', 'GET', params);
     return result;
   }
+
+  /**
+   * Get the AI-generated summary for a video room's transcript
+   * @param {string} roomId - The video room ID
+   * @returns {Promise} Meeting summary
+   */
+  async getSummary(roomId) {
+    this.sdk.validateParams(
+      { roomId },
+      {
+        roomId: { type: 'string', required: true },
+      },
+    );
+
+    const result = await this.sdk._fetch(`/video/${roomId}/summary`, 'GET');
+    return result;
+  }
+
+  /**
+   * Host-only edit of a video room's post-meeting AI summary
+   * @param {string} roomId - The video room ID
+   * @param {Object} update
+   * @param {Object} update.summaryJson - {title, summary, actionItems, chapters}
+   * @returns {Promise} Update result
+   */
+  async updateSummary(roomId, { summaryJson }) {
+    this.sdk.validateParams(
+      { roomId, summaryJson },
+      {
+        roomId: { type: 'string', required: true },
+        summaryJson: { type: 'object', required: true },
+      },
+    );
+
+    const params = {
+      body: { summaryJson },
+    };
+
+    const result = await this.sdk._fetch(
+      `/video/${roomId}/summary`,
+      'PATCH',
+      params,
+    );
+    return result;
+  }
+
+  /**
+   * Generate a "catch me up" recap of a video room's transcript so far
+   * @param {string} roomId - The video room ID
+   * @returns {Promise} Catch-up summary
+   */
+  async catchMeUp(roomId) {
+    this.sdk.validateParams(
+      { roomId },
+      {
+        roomId: { type: 'string', required: true },
+      },
+    );
+
+    const result = await this.sdk._fetch(
+      `/video/${roomId}/catch-me-up`,
+      'POST',
+      {},
+    );
+    return result;
+  }
+
+  /**
+   * Ask the room-scoped AI assistant a question, grounded in the meeting
+   * transcript so far
+   * @param {string} roomId - The video room ID
+   * @param {Object} params
+   * @param {string} params.question - The question to ask
+   * @param {Array<{role: 'user'|'assistant', content: string}>} [params.history] - Prior turns
+   * @returns {Promise} Assistant answer
+   */
+  async assistantChat(roomId, { question, history } = {}) {
+    this.sdk.validateParams(
+      { roomId, question },
+      {
+        roomId: { type: 'string', required: true },
+        question: { type: 'string', required: true },
+      },
+    );
+
+    const body = { question };
+    if (history !== undefined) {
+      body.history = history;
+    }
+
+    const result = await this.sdk._fetch(`/video/${roomId}/assistant`, 'POST', {
+      body,
+    });
+    return result;
+  }
+
+  /**
+   * Update the text of a transcript message
+   * @param {string} roomId - The video room ID
+   * @param {string} messageId - The transcript message ID
+   * @param {Object} update
+   * @param {string} update.text - New transcript text
+   * @returns {Promise} Updated transcript message
+   */
+  async updateTranscriptMessage(roomId, messageId, { text }) {
+    this.sdk.validateParams(
+      { roomId, messageId, text },
+      {
+        roomId: { type: 'string', required: true },
+        messageId: { type: 'string', required: true },
+        text: { type: 'string', required: true },
+      },
+    );
+
+    const params = {
+      body: { text },
+    };
+
+    const result = await this.sdk._fetch(
+      `/video/${roomId}/transcript/${messageId}`,
+      'PATCH',
+      params,
+    );
+    return result;
+  }
+
+  /**
+   * Redact a transcript message
+   * @param {string} roomId - The video room ID
+   * @param {string} messageId - The transcript message ID
+   * @returns {Promise} Redaction result
+   */
+  async redactTranscriptMessage(roomId, messageId) {
+    this.sdk.validateParams(
+      { roomId, messageId },
+      {
+        roomId: { type: 'string', required: true },
+        messageId: { type: 'string', required: true },
+      },
+    );
+
+    const result = await this.sdk._fetch(
+      `/video/${roomId}/transcript/${messageId}/redact`,
+      'POST',
+      {},
+    );
+    return result;
+  }
+
+  /**
+   * Rename a speaker in the transcript for a video room
+   * @param {string} roomId - The video room ID
+   * @param {Object} update
+   * @param {string} update.participantId - Participant ID whose transcript speaker name to update
+   * @param {string} update.displayName - New display name
+   * @returns {Promise} Update result
+   */
+  async renameTranscriptSpeaker(roomId, { participantId, displayName }) {
+    this.sdk.validateParams(
+      { roomId, participantId, displayName },
+      {
+        roomId: { type: 'string', required: true },
+        participantId: { type: 'string', required: true },
+        displayName: { type: 'string', required: true },
+      },
+    );
+
+    const params = {
+      body: { participantId, displayName },
+    };
+
+    const result = await this.sdk._fetch(
+      `/video/${roomId}/transcript-speakers`,
+      'PATCH',
+      params,
+    );
+    return result;
+  }
 }