@mentra/sdk 2.1.13 → 2.1.15

package/dist/types/streams.js

@@ -122,44 +122,78 @@ function isValidLanguageCode(code) {
 /**
  * Parse a subscription string to extract language information
  *
- * @param subscription Subscription string (e.g., "transcription:en-US" or "translation:es-ES-to-en-US")
+ * @param subscription Subscription string (e.g., "transcription:en-US" or "translation:es-ES-to-en-US" or "transcription:en-US?no-language-identification=true")
  * @returns Parsed language stream info or null if not a language-specific subscription
  */
 function parseLanguageStream(subscription) {
-    if (typeof subscription !== 'string') {
+    console.log(`🎤 Parsing language stream: ${subscription}`);
+    if (typeof subscription !== "string") {
         return null;
     }
-    // console.log(`🎤 Parsing language stream: ${subscription}`);
-    // Handle transcription format (transcription:en-US)
+    // Handle transcription format (transcription:en-US or transcription:en-US?options)
     if (subscription.startsWith(`${StreamType.TRANSCRIPTION}:`)) {
-        const [baseType, languageCode] = subscription.split(':');
-        // console.log(`🎤 Parsing transcription stream: ${subscription}`);
-        // console.log(`🎤 Language code: ${languageCode}`);
+        const [baseType, rest] = subscription.split(":");
+        const [languageCode, queryString] = rest?.split("?") ?? [];
         if (languageCode && isValidLanguageCode(languageCode)) {
+            const options = {};
+            // Parse query parameters if present
+            if (queryString) {
+                const params = new URLSearchParams(queryString);
+                for (const [key, value] of params.entries()) {
+                    // Convert string values to boolean when appropriate
+                    if (value === "true") {
+                        options[key] = true;
+                    }
+                    else if (value === "false") {
+                        options[key] = false;
+                    }
+                    else {
+                        options[key] = value;
+                    }
+                }
+            }
             return {
                 type: StreamType.TRANSCRIPTION,
                 baseType,
                 transcribeLanguage: languageCode,
-                original: subscription
+                options: Object.keys(options).length > 0 ? options : undefined,
+                original: subscription,
             };
         }
     }
-    // Handle translation format (translation:es-ES-to-en-US)
+    // Handle translation format (translation:es-ES-to-en-US or translation:es-ES-to-en-US?options)
     if (subscription.startsWith(`${StreamType.TRANSLATION}:`)) {
-        const [baseType, languagePair] = subscription.split(':');
-        const [sourceLanguage, targetLanguage] = languagePair?.split('-to-') ?? [];
-        // console.log(`🎤 Parsing translation stream: ${subscription}`);
-        // console.log(`🎤 Source language: ${sourceLanguage}`);
-        // console.log(`🎤 Target language: ${targetLanguage}`);
-        if (sourceLanguage && targetLanguage &&
+        const [baseType, rest] = subscription.split(":");
+        const [languagePair, queryString] = rest?.split("?") ?? [];
+        const [sourceLanguage, targetLanguage] = languagePair?.split("-to-") ?? [];
+        if (sourceLanguage &&
+            targetLanguage &&
             isValidLanguageCode(sourceLanguage) &&
             isValidLanguageCode(targetLanguage)) {
+            const options = {};
+            // Parse query parameters if present
+            if (queryString) {
+                const params = new URLSearchParams(queryString);
+                for (const [key, value] of params.entries()) {
+                    // Convert string values to boolean when appropriate
+                    if (value === "true") {
+                        options[key] = true;
+                    }
+                    else if (value === "false") {
+                        options[key] = false;
+                    }
+                    else {
+                        options[key] = value;
+                    }
+                }
+            }
             return {
                 type: StreamType.TRANSLATION,
                 baseType,
                 transcribeLanguage: sourceLanguage,
                 translateLanguage: targetLanguage,
-                original: subscription
+                options: Object.keys(options).length > 0 ? options : undefined,
+                original: subscription,
             };
         }
     }
@@ -172,11 +206,19 @@ function parseLanguageStream(subscription) {
  * @param language Language code (e.g., "en-US")
  * @returns Typed stream identifier
  */
-function createTranscriptionStream(language) {
-    if (!isValidLanguageCode(language)) {
-        throw new Error(`Invalid language code: ${language}`);
+function createTranscriptionStream(language, options) {
+    console.log(`🎤 Creating transcription stream for language: ${language}`);
+    console.log(`🎤 Options: ${JSON.stringify(options)}`);
+    // Defensively remove any query string from the language parameter
+    const languageCode = language.split("?")[0];
+    if (!isValidLanguageCode(languageCode)) {
+        throw new Error(`Invalid language code: ${languageCode}`);
     }
-    return createLanguageStream(`${StreamType.TRANSCRIPTION}:${language}`);
+    const base = `${StreamType.TRANSCRIPTION}:${languageCode}`;
+    if (options?.disableLanguageIdentification) {
+        return `${base}?no-language-identification=true`;
+    }
+    return base;
 }
 /**
  * Create a translation stream identifier for a language pair
@@ -184,13 +226,22 @@ function createTranscriptionStream(language) {
  *
  * @param sourceLanguage Source language code (e.g., "es-ES")
  * @param targetLanguage Target language code (e.g., "en-US")
+ * @param options Optional configuration options
  * @returns Typed stream identifier
  */
-function createTranslationStream(sourceLanguage, targetLanguage) {
-    if (!isValidLanguageCode(sourceLanguage) || !isValidLanguageCode(targetLanguage)) {
-        throw new Error(`Invalid language code(s): ${sourceLanguage}, ${targetLanguage}`);
+function createTranslationStream(sourceLanguage, targetLanguage, options) {
+    // Defensively remove any query string from the language parameters
+    const cleanSourceLanguage = sourceLanguage.split("?")[0];
+    const cleanTargetLanguage = targetLanguage.split("?")[0];
+    if (!isValidLanguageCode(cleanSourceLanguage) ||
+        !isValidLanguageCode(cleanTargetLanguage)) {
+        throw new Error(`Invalid language code(s): ${cleanSourceLanguage}, ${cleanTargetLanguage}`);
+    }
+    const base = `${StreamType.TRANSLATION}:${cleanSourceLanguage}-to-${cleanTargetLanguage}`;
+    if (options?.disableLanguageIdentification) {
+        return `${base}?no-language-identification=true`;
     }
-    return createLanguageStream(`${StreamType.TRANSLATION}:${sourceLanguage}-to-${targetLanguage}`);
+    return createLanguageStream(base);
 }
 /**
  * Check if a subscription is a valid stream type

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mentra/sdk",
-  "version": "2.1.13",
+  "version": "2.1.15",
   "description": "Build apps for MentraOS smartglasses. This SDK provides everything you need to create real-time smartglasses applications.",
   "source": "src/index.ts",
   "main": "dist/index.js",