@unboundcx/sdk 4.0.11 → 4.0.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unboundcx/sdk",
-  "version": "4.0.11",
+  "version": "4.0.13",
   "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

@@ -108,6 +108,10 @@ message AudioRequest {
   // SilenceDetector), instead of relying on client-sent vad_event fields.
   // Defaults to false/unset: existing (non-Meet) callers are unaffected.
   bool server_vad = 26;
+
+  // Optional custom vocabulary terms to bias transcription toward
+  // (e.g. product names, jargon). Merged account + room terms, capped.
+  repeated string vocabulary = 27;
 }
 
 // Audio configuration

package/services/ai/SttStream.js

@@ -167,6 +167,8 @@ export class SttStream extends EventEmitter {
    * 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.
+   * @param {string[]} [options.vocabulary] - Custom vocabulary terms to bias
+   * transcription toward (sent once in the first-chunk session config).
    */
   write(audioChunk, streamMetadata = {}) {
     if (this.isClosed) {
@@ -223,6 +225,7 @@ export class SttStream extends EventEmitter {
           participant_id: this.options.participantId || '',
           display_name: this.options.displayName || '',
           server_vad: this.options.serverVad || false,
+          vocabulary: this.options.vocabulary || [],
         };
 
         this.grpcCall.write(request);

package/services/ai/settings.js

@@ -0,0 +1,37 @@
+/**
+ * AI Settings helpers - Manage account-level AI feature settings
+ * Exposed directly on AIService as getSettings()/updateSettings()
+ */
+
+/**
+ * Get account AI settings
+ * @param {Object} sdk
+ * @returns {Promise<Object>} { settings: { shareOcrEnabled } }
+ */
+export async function getSettings(sdk) {
+  const result = await sdk._fetch('/ai/settings', 'GET');
+  return result;
+}
+
+/**
+ * Update account AI settings
+ * @param {Object} sdk
+ * @param {Object} options
+ * @param {boolean} options.shareOcrEnabled - Whether shared-content OCR is enabled
+ * @returns {Promise<Object>} { settings }
+ */
+export async function updateSettings(sdk, { shareOcrEnabled }) {
+  sdk.validateParams(
+    { shareOcrEnabled },
+    {
+      shareOcrEnabled: { type: 'boolean', required: true },
+    },
+  );
+
+  const params = {
+    body: { shareOcrEnabled },
+  };
+
+  const result = await sdk._fetch('/ai/settings', 'PUT', params);
+  return result;
+}

package/services/ai/translate.js

@@ -0,0 +1,38 @@
+/**
+ * AI Translate helper - Batch-translate arbitrary text items
+ * Exposed directly on AIService as translate()
+ */
+
+/**
+ * Translate a batch of text items
+ * @param {Object} sdk
+ * @param {Object} options
+ * @param {Array<{id: string, text: string}>} options.items - Items to translate
+ * @param {string} options.targetLanguage - Target language code
+ * @param {string} [options.sourceLanguage] - Source language code (auto-detect if omitted)
+ * @param {string} [options.domain] - Optional domain hint for translation quality
+ * @param {string} [options.context] - Optional additional context
+ * @returns {Promise<Object>} { items: [{id, text}] }
+ */
+export async function translate(
+  sdk,
+  { items, targetLanguage, sourceLanguage, domain, context },
+) {
+  sdk.validateParams(
+    { items, targetLanguage, sourceLanguage, domain, context },
+    {
+      items: { type: 'array', required: true },
+      targetLanguage: { type: 'string', required: true },
+      sourceLanguage: { type: 'string', required: false },
+      domain: { type: 'string', required: false },
+      context: { type: 'string', required: false },
+    },
+  );
+
+  const params = {
+    body: { items, targetLanguage, sourceLanguage, domain, context },
+  };
+
+  const result = await sdk._fetch('/ai/translate', 'POST', params);
+  return result;
+}

package/services/ai/vocabulary.js

@@ -0,0 +1,55 @@
+/**
+ * Vocabulary Service - Manage account-level custom transcription vocabulary
+ */
+export class VocabularyService {
+  constructor(sdk) {
+    this.sdk = sdk;
+  }
+
+  /**
+   * List account custom vocabulary terms
+   * @returns {Promise<Object>} { terms: [{id, term, createdBy, createdAt}] }
+   */
+  async list() {
+    const result = await this.sdk._fetch('/ai/vocabulary', 'GET');
+    return result;
+  }
+
+  /**
+   * Add a custom vocabulary term (deduped case-insensitive, max 120 chars)
+   * @param {string} term - The vocabulary term to add
+   * @returns {Promise<Object>} { term: {id, term, createdBy, createdAt} }
+   */
+  async add(term) {
+    this.sdk.validateParams(
+      { term },
+      {
+        term: { type: 'string', required: true },
+      },
+    );
+
+    const params = {
+      body: { term },
+    };
+
+    const result = await this.sdk._fetch('/ai/vocabulary', 'POST', params);
+    return result;
+  }
+
+  /**
+   * Remove a custom vocabulary term
+   * @param {string} id - The vocabulary term ID
+   * @returns {Promise} 204-style response
+   */
+  async remove(id) {
+    this.sdk.validateParams(
+      { id },
+      {
+        id: { type: 'string', required: true },
+      },
+    );
+
+    const result = await this.sdk._fetch(`/ai/vocabulary/${id}`, 'DELETE');
+    return result;
+  }
+}

package/services/ai.js

@@ -1,4 +1,10 @@
 import { PlaybooksService } from './ai/playbooks.js';
+import { VocabularyService } from './ai/vocabulary.js';
+import { translate as translateItems } from './ai/translate.js';
+import {
+  getSettings as getAiSettings,
+  updateSettings as updateAiSettings,
+} from './ai/settings.js';
 
 export class AIService {
   constructor(sdk) {
@@ -8,6 +14,33 @@ export class AIService {
     this.stt = new SpeechToTextService(sdk);
     this.extract = new ExtractService(sdk);
     this.playbooks = new PlaybooksService(sdk);
+    this.vocabulary = new VocabularyService(sdk);
+  }
+
+  /**
+   * Translate a batch of text items
+   * @param {Object} params - { items, targetLanguage, sourceLanguage?, domain?, context? }
+   * @returns {Promise<Object>} { items: [{id, text}] }
+   */
+  async translate(params) {
+    return translateItems(this.sdk, params);
+  }
+
+  /**
+   * Get account AI settings
+   * @returns {Promise<Object>} { settings: { shareOcrEnabled } }
+   */
+  async getSettings() {
+    return getAiSettings(this.sdk);
+  }
+
+  /**
+   * Update account AI settings
+   * @param {Object} options - { shareOcrEnabled }
+   * @returns {Promise<Object>} { settings }
+   */
+  async updateSettings(options) {
+    return updateAiSettings(this.sdk, options);
   }
 }
 
@@ -224,6 +257,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 }

package/services/video.js

@@ -228,6 +228,8 @@ export class VideoService {
     calendarId,
     eventId,
     calendarProvider,
+    vocabularyTerms,
+    shareOcrEnabled,
   }) {
     this.sdk.validateParams(
       {
@@ -255,6 +257,8 @@ export class VideoService {
         calendarId,
         eventId,
         calendarProvider,
+        vocabularyTerms,
+        shareOcrEnabled,
       },
       {
         name: { type: 'string', required: false },
@@ -281,6 +285,8 @@ export class VideoService {
         calendarId: { type: 'string', required: false },
         eventId: { type: 'string', required: false },
         calendarProvider: { type: 'string', required: false },
+        vocabularyTerms: { type: 'array', required: false },
+        shareOcrEnabled: { type: 'boolean', required: false },
       },
     );
     const params = {
@@ -309,6 +315,8 @@ export class VideoService {
         calendarId,
         eventId,
         calendarProvider,
+        vocabularyTerms,
+        shareOcrEnabled,
       },
     };
     const result = await this.sdk._fetch(`/video`, 'POST', params);
@@ -350,6 +358,10 @@ export class VideoService {
       validationSchema.startTranscribingOn = { type: 'boolean' };
     if ('enableChat' in update)
       validationSchema.enableChat = { type: 'boolean' };
+    if ('vocabularyTerms' in update)
+      validationSchema.vocabularyTerms = { type: 'array' };
+    if ('shareOcrEnabled' in update)
+      validationSchema.shareOcrEnabled = { type: 'boolean' };
 
     if (Object.keys(validationSchema).length > 0) {
       this.sdk.validateParams(update, validationSchema);
@@ -1030,4 +1042,355 @@ 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;
+  }
+
+  /**
+   * Host-only manual retry for a stuck/failed webm->mp4 recording conversion
+   * @param {string} roomId - The video room ID
+   * @returns {Promise} { launched: true } on success
+   */
+  async retryRecordingConvert(roomId) {
+    this.sdk.validateParams(
+      { roomId },
+      {
+        roomId: { type: 'string', required: true },
+      },
+    );
+
+    const result = await this.sdk._fetch(
+      `/video/${roomId}/recording-convert-retry`,
+      'POST',
+      {},
+    );
+    return result;
+  }
+
+  /**
+   * Host-triggered "generate meeting name from transcript" action. Always
+   * force-regenerates the room name.
+   * @param {string} roomId - The video room ID
+   * @returns {Promise} { ok: true, name: string } on success
+   */
+  async autoNameMeeting(roomId) {
+    this.sdk.validateParams(
+      { roomId },
+      {
+        roomId: { type: 'string', required: true },
+      },
+    );
+
+    const result = await this.sdk._fetch(`/video/${roomId}/auto-name`, 'POST', {});
+    return result;
+  }
+
+  /**
+   * Host-authorized live-transcription toggle, mirrors the recording control
+   * @param {string} roomId - The video room ID
+   * @param {'start'|'stop'} action - Whether to start or stop transcription
+   * @returns {Promise} { action, ok: true } on success
+   */
+  async controlTranscription(roomId, action) {
+    this.sdk.validateParams(
+      { roomId, action },
+      {
+        roomId: { type: 'string', required: true },
+        action: { type: 'string', required: true },
+      },
+    );
+
+    const params = {
+      body: { action },
+    };
+
+    const result = await this.sdk._fetch(
+      `/video/${roomId}/transcription`,
+      'POST',
+      params,
+    );
+    return result;
+  }
+
+  /**
+   * Set the caption language for the calling participant in a video room
+   * @param {string} roomId - The video room ID
+   * @param {Object} options
+   * @param {string} options.language - Language code, or 'original' for no translation
+   * @returns {Promise} { ok: true } on success
+   */
+  async setCaptionLanguage(roomId, { language }) {
+    this.sdk.validateParams(
+      { roomId, language },
+      {
+        roomId: { type: 'string', required: true },
+        language: { type: 'string', required: true },
+      },
+    );
+
+    const params = {
+      body: { language },
+    };
+
+    const result = await this.sdk._fetch(
+      `/video/${roomId}/caption-language`,
+      'POST',
+      params,
+    );
+    return result;
+  }
+
+  /**
+   * Translate a video room's full transcript into a target language (account users).
+   * Batches the full transcript and caches translations server-side.
+   * @param {string} roomId - The video room ID
+   * @param {Object} options
+   * @param {string} options.targetLanguage - Target language code
+   * @returns {Promise} { items: [{messageId, text}] }
+   */
+  async translateTranscript(roomId, { targetLanguage }) {
+    this.sdk.validateParams(
+      { roomId, targetLanguage },
+      {
+        roomId: { type: 'string', required: true },
+        targetLanguage: { type: 'string', required: true },
+      },
+    );
+
+    const params = {
+      body: { targetLanguage },
+    };
+
+    const result = await this.sdk._fetch(
+      `/video/${roomId}/transcript/translate`,
+      'POST',
+      params,
+    );
+    return result;
+  }
+
+  /**
+   * Submit a captured content-share keyframe for OCR/indexing
+   * @param {string} roomId - The video room ID
+   * @param {Object} options
+   * @param {string} options.image - Base64 jpeg image data (no data: prefix)
+   * @param {string} [options.title] - Optional title for the content frame
+   * @returns {Promise} { event }
+   */
+  async submitContentFrame(roomId, { image, title }) {
+    this.sdk.validateParams(
+      { roomId, image, title },
+      {
+        roomId: { type: 'string', required: true },
+        image: { type: 'string', required: true },
+        title: { type: 'string', required: false },
+      },
+    );
+
+    const params = {
+      body: { image, title },
+    };
+
+    const result = await this.sdk._fetch(
+      `/video/${roomId}/content-frame`,
+      'POST',
+      params,
+    );
+    return result;
+  }
+
+  /**
+   * Get captured content-share events for a video room
+   * @param {string} roomId - The video room ID
+   * @returns {Promise} { events: [{id, participantId, displayName, timestamp, title, text, fileId}] }
+   */
+  async getContentEvents(roomId) {
+    this.sdk.validateParams(
+      { roomId },
+      {
+        roomId: { type: 'string', required: true },
+      },
+    );
+
+    const result = await this.sdk._fetch(
+      `/video/${roomId}/content-events`,
+      'GET',
+    );
+    return result;
+  }
 }