@garrix82/reactgenie-lib 1.3.0

package/dist/speech-recognition/utils/groq-transcription.d.ts

@@ -0,0 +1,41 @@
+type ReactNativeFile = {
+    uri: string;
+    name?: string;
+    type?: string;
+};
+export type GroqTranscriptionOptions = {
+    apiKey: string;
+    audioBlob: Blob | ReactNativeFile;
+    mimeType: string;
+    language?: string;
+    model?: string;
+    responseFormat?: 'json' | 'verbose_json';
+    stream?: boolean;
+    signal?: AbortSignal;
+    endpoint?: string;
+    onInterim?: (text: string) => void;
+};
+export type GroqTranslationOptions = {
+    apiKey: string;
+    audioBlob: Blob | ReactNativeFile;
+    mimeType: string;
+    language?: string;
+    model?: string;
+    responseFormat?: 'json' | 'verbose_json';
+    signal?: AbortSignal;
+    endpoint?: string;
+};
+export type GroqTextTranslationOptions = {
+    apiKey: string;
+    text: string;
+    language?: string;
+    targetLanguage?: string;
+    model?: string;
+    signal?: AbortSignal;
+    endpoint?: string;
+};
+export declare function streamGroqTranscription({ apiKey, audioBlob, mimeType, language, model, responseFormat, stream, signal, endpoint, onInterim, }: GroqTranscriptionOptions): Promise<string>;
+export declare function translateGroqAudio({ apiKey, audioBlob, mimeType, language, model, responseFormat, signal, endpoint, }: GroqTranslationOptions): Promise<string>;
+export declare function translateGroqText({ apiKey, text, language, targetLanguage, model, signal, endpoint, }: GroqTextTranslationOptions): Promise<string>;
+export declare function mergeTranscriptParts(base: string, addition: string): string;
+export {};

package/dist/speech-recognition/utils/groq-transcription.js

@@ -0,0 +1,382 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.mergeTranscriptParts = mergeTranscriptParts;
+exports.streamGroqTranscription = streamGroqTranscription;
+exports.translateGroqAudio = translateGroqAudio;
+exports.translateGroqText = translateGroqText;
+var _logger = _interopRequireDefault(require("../../logger"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const DEFAULT_ENDPOINT = 'https://api.groq.com/openai/v1/audio/transcriptions';
+const DEFAULT_TRANSLATION_ENDPOINT = 'https://api.groq.com/openai/v1/audio/translations';
+const DEFAULT_CHAT_COMPLETIONS_ENDPOINT = 'https://api.groq.com/openai/v1/chat/completions';
+async function streamGroqTranscription({
+  apiKey,
+  audioBlob,
+  mimeType,
+  language = 'en',
+  model = 'whisper-large-v3',
+  responseFormat = 'verbose_json',
+  stream = true,
+  signal,
+  endpoint = DEFAULT_ENDPOINT,
+  onInterim
+}) {
+  const fileName = isReactNativeFile(audioBlob) ? audioBlob.name || `audio.${getFileExtension(mimeType)}` : `audio.${getFileExtension(mimeType)}`;
+  const formData = new FormData();
+  if (isReactNativeFile(audioBlob)) {
+    formData.append('file', {
+      uri: audioBlob.uri,
+      name: fileName,
+      type: audioBlob.type || mimeType
+    });
+  } else {
+    const file = createAudioFile(audioBlob, fileName, mimeType);
+    if (file && typeof file === 'object') {
+      if (file instanceof Blob && !file.name) {
+        formData.append('file', file, fileName);
+      } else {
+        formData.append('file', file);
+      }
+    }
+  }
+  formData.append('model', model);
+  formData.append('language', language);
+  formData.append('response_format', responseFormat);
+  const url = stream ? `${endpoint}?stream=true` : endpoint;
+  if (stream && isReactNativeEnv() && typeof XMLHttpRequest !== 'undefined') {
+    _logger.default.warn('[Groq SSE] using XHR streaming (React Native)');
+    return streamGroqTranscriptionViaXhr({
+      apiKey,
+      formData,
+      url,
+      signal,
+      onInterim
+    });
+  }
+  const response = await fetch(url, {
+    method: 'POST',
+    headers: {
+      Authorization: `Bearer ${apiKey}`
+    },
+    body: formData,
+    signal
+  });
+  if (!response.ok) {
+    const errorBody = await response.text().catch(() => '');
+    throw buildHttpError(response.status, errorBody);
+  }
+  let lastText = '';
+  const handleLine = line => {
+    const trimmed = line.trim();
+    if (!trimmed) return;
+    const payload = trimmed.startsWith('data:') ? trimmed.slice(5).trim() : trimmed;
+    if (!payload) return;
+    try {
+      const parsed = JSON.parse(payload);
+      const text = extractText(parsed);
+      if (text) {
+        lastText = text;
+        if (onInterim) onInterim(text);
+      }
+    } catch {
+      // ignore non-JSON lines
+    }
+  };
+  const reader = response.body?.getReader?.();
+  if (reader && typeof TextDecoder !== 'undefined') {
+    const decoder = new TextDecoder();
+    let buffer = '';
+    while (true) {
+      const {
+        value,
+        done
+      } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, {
+        stream: true
+      });
+      const lines = buffer.split('\n');
+      buffer = lines.pop() || '';
+      for (const line of lines) {
+        handleLine(line);
+      }
+    }
+    if (buffer) {
+      handleLine(buffer);
+    }
+  } else {
+    const text = await response.text();
+    const lines = text.split('\n');
+    for (const line of lines) {
+      handleLine(line);
+    }
+  }
+  return lastText;
+}
+async function translateGroqAudio({
+  apiKey,
+  audioBlob,
+  mimeType,
+  language,
+  model = 'whisper-large-v3',
+  responseFormat = 'json',
+  signal,
+  endpoint = DEFAULT_TRANSLATION_ENDPOINT
+}) {
+  const fileName = isReactNativeFile(audioBlob) ? audioBlob.name || `audio.${getFileExtension(mimeType)}` : `audio.${getFileExtension(mimeType)}`;
+  const formData = new FormData();
+  if (isReactNativeFile(audioBlob)) {
+    formData.append('file', {
+      uri: audioBlob.uri,
+      name: fileName,
+      type: audioBlob.type || mimeType
+    });
+  } else {
+    const file = createAudioFile(audioBlob, fileName, mimeType);
+    if (file && typeof file === 'object') {
+      if (file instanceof Blob && !file.name) {
+        formData.append('file', file, fileName);
+      } else {
+        formData.append('file', file);
+      }
+    }
+  }
+  formData.append('model', model);
+  if (language) {
+    formData.append('language', language);
+  }
+  formData.append('response_format', responseFormat);
+  const response = await fetch(endpoint, {
+    method: 'POST',
+    headers: {
+      Authorization: `Bearer ${apiKey}`
+    },
+    body: formData,
+    signal
+  });
+  if (!response.ok) {
+    const errorBody = await response.text().catch(() => '');
+    throw buildHttpError(response.status, errorBody);
+  }
+  let payload = null;
+  try {
+    payload = await response.json();
+  } catch {
+    const text = await response.text().catch(() => '');
+    return text.trim();
+  }
+  return extractText(payload);
+}
+async function translateGroqText({
+  apiKey,
+  text,
+  language,
+  targetLanguage = 'English',
+  model = 'llama-3.1-8b-instant',
+  signal,
+  endpoint = DEFAULT_CHAT_COMPLETIONS_ENDPOINT
+}) {
+  const input = text.trim();
+  if (!input) return '';
+  const response = await fetch(endpoint, {
+    method: 'POST',
+    headers: {
+      Authorization: 'Bearer ' + apiKey,
+      'Content-Type': 'application/json'
+    },
+    body: JSON.stringify({
+      model,
+      temperature: 0,
+      stream: false,
+      messages: [{
+        role: 'system',
+        content: 'Translate user text accurately. Return only translated text without commentary.'
+      }, {
+        role: 'user',
+        content: language ? 'Translate from ' + language + ' to ' + targetLanguage + ': ' + input : 'Translate to ' + targetLanguage + ': ' + input
+      }]
+    }),
+    signal
+  });
+  if (!response.ok) {
+    const errorBody = await response.text().catch(() => '');
+    throw buildHttpError(response.status, errorBody);
+  }
+  const payload = await response.json().catch(() => null);
+  const translated = extractChatCompletionText(payload);
+  if (translated) return translated.trim();
+  return extractText(payload);
+}
+function mergeTranscriptParts(base, addition) {
+  const a = base.trim();
+  const b = addition.trim();
+  if (!a) return b;
+  if (!b) return a;
+  if (a.endsWith(b)) return a;
+  if (b.startsWith(a)) return b;
+  return `${a} ${b}`.trim();
+}
+function createAudioFile(audioBlob, name, mimeType) {
+  if (typeof File !== 'undefined') {
+    try {
+      return new File([audioBlob], name, {
+        type: mimeType
+      });
+    } catch {
+      return audioBlob;
+    }
+  }
+  return audioBlob;
+}
+function streamGroqTranscriptionViaXhr(options) {
+  return new Promise((resolve, reject) => {
+    const xhr = new XMLHttpRequest();
+    let lastText = '';
+    let processedLength = 0;
+    let buffer = '';
+    const debug = shouldDebugSse();
+    const log = debug ? _logger.default.warn : _logger.default.debug;
+    const handleLine = line => {
+      const trimmed = line.trim();
+      if (!trimmed) return;
+      const payload = trimmed.startsWith('data:') ? trimmed.slice(5).trim() : trimmed;
+      if (!payload) return;
+      if (payload === '[DONE]') return;
+      try {
+        const parsed = JSON.parse(payload);
+        const text = extractText(parsed);
+        if (text) {
+          lastText = text;
+          log('[Groq SSE] interim:', text);
+          if (options.onInterim) options.onInterim(text);
+        }
+      } catch {
+        // ignore non-JSON lines
+      }
+    };
+    xhr.open('POST', options.url, true);
+    xhr.setRequestHeader('Authorization', `Bearer ${options.apiKey}`);
+    xhr.responseType = 'text';
+    const processIncremental = () => {
+      const text = xhr.responseText || '';
+      const chunk = text.slice(processedLength);
+      if (!chunk) return;
+      processedLength = text.length;
+      buffer += chunk;
+      log('[Groq SSE] chunk bytes:', chunk.length);
+      const lines = buffer.split('\n');
+      buffer = lines.pop() || '';
+      for (const line of lines) {
+        handleLine(line);
+      }
+    };
+    xhr.onreadystatechange = () => {
+      if (xhr.readyState === XMLHttpRequest.LOADING) {
+        processIncremental();
+        return;
+      }
+      if (xhr.readyState === XMLHttpRequest.DONE) {
+        if (xhr.status >= 200 && xhr.status < 300) {
+          if (buffer) {
+            handleLine(buffer);
+            buffer = '';
+          }
+          processIncremental();
+          resolve(lastText);
+        } else if (xhr.status === 0) {
+          // Status 0 in React Native usually means the request never reached the server
+          reject(new Error(`Groq API network error (status 0). Check device connectivity, HTTP/ATS cleartext settings, and endpoint URL: ${options.url}`));
+        } else {
+          reject(buildHttpError(xhr.status, xhr.responseText || ''));
+        }
+      }
+    };
+    xhr.onprogress = () => {
+      processIncremental();
+    };
+    xhr.onerror = () => {
+      reject(new Error('Groq API network error'));
+    };
+    if (options.signal) {
+      if (options.signal.aborted) {
+        xhr.abort();
+        reject(new Error('AbortError'));
+        return;
+      }
+      options.signal.addEventListener('abort', () => {
+        xhr.abort();
+        reject(new Error('AbortError'));
+      }, {
+        once: true
+      });
+    }
+    xhr.send(options.formData);
+  });
+}
+function isReactNativeFile(value) {
+  return !!value && typeof value === 'object' && 'uri' in value;
+}
+function isReactNativeEnv() {
+  return typeof navigator !== 'undefined' && navigator.product === 'ReactNative';
+}
+function shouldDebugSse() {
+  return typeof __DEV__ !== 'undefined' ? __DEV__ : false;
+}
+function extractChatCompletionText(payload) {
+  const content = payload?.choices?.[0]?.message?.content;
+  if (typeof content === 'string') {
+    return content.trim();
+  }
+  if (Array.isArray(content)) {
+    const joined = content.map(part => {
+      if (typeof part?.text === 'string') return part.text;
+      if (typeof part?.content === 'string') return part.content;
+      return '';
+    }).join('').trim();
+    return joined;
+  }
+  return '';
+}
+function extractText(payload) {
+  if (!payload || typeof payload !== 'object') return '';
+  const directText = typeof payload.text === 'string' ? payload.text : '';
+  if (directText) return directText.trim();
+  const deltaText = payload.delta && typeof payload.delta.text === 'string' ? payload.delta.text : '';
+  if (deltaText) return deltaText.trim();
+  const dataText = payload.data && typeof payload.data.text === 'string' ? payload.data.text : '';
+  if (dataText) return dataText.trim();
+  const choiceText = payload.choices?.[0]?.delta?.content || payload.choices?.[0]?.text || '';
+  return typeof choiceText === 'string' ? choiceText.trim() : '';
+}
+function buildHttpError(status, rawBody) {
+  const detail = extractErrorMessage(rawBody);
+  const suffix = detail ? ` - ${detail}` : '';
+  return new Error(`Groq API error: ${status}${suffix}`);
+}
+function extractErrorMessage(rawBody) {
+  if (!rawBody) return '';
+  const trimmed = rawBody.trim();
+  if (!trimmed) return '';
+  try {
+    const parsed = JSON.parse(trimmed);
+    const message = parsed?.error?.message || parsed?.error || parsed?.message || parsed?.detail || '';
+    if (typeof message === 'string' && message.trim()) {
+      return message.trim();
+    }
+  } catch {
+    // ignore JSON parse failures
+  }
+  return trimmed.slice(0, 300);
+}
+function getFileExtension(mimeType) {
+  if (mimeType.includes('webm')) return 'webm';
+  if (mimeType.includes('ogg')) return 'ogg';
+  if (mimeType.includes('mp4')) return 'mp4';
+  if (mimeType.includes('wav')) return 'wav';
+  if (mimeType.includes('m4a')) return 'm4a';
+  return 'webm';
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_logger","_interopRequireDefault","require","e","__esModule","default","DEFAULT_ENDPOINT","DEFAULT_TRANSLATION_ENDPOINT","DEFAULT_CHAT_COMPLETIONS_ENDPOINT","streamGroqTranscription","apiKey","audioBlob","mimeType","language","model","responseFormat","stream","signal","endpoint","onInterim","fileName","isReactNativeFile","name","getFileExtension","formData","FormData","append","uri","type","file","createAudioFile","Blob","url","isReactNativeEnv","XMLHttpRequest","logger","warn","streamGroqTranscriptionViaXhr","response","fetch","method","headers","Authorization","body","ok","errorBody","text","catch","buildHttpError","status","lastText","handleLine","line","trimmed","trim","payload","startsWith","slice","parsed","JSON","parse","extractText","reader","getReader","TextDecoder","decoder","buffer","value","done","read","decode","lines","split","pop","translateGroqAudio","json","translateGroqText","targetLanguage","input","stringify","temperature","messages","role","content","translated","extractChatCompletionText","mergeTranscriptParts","base","addition","a","b","endsWith","File","options","Promise","resolve","reject","xhr","processedLength","debug","shouldDebugSse","log","open","setRequestHeader","responseType","processIncremental","responseText","chunk","length","onreadystatechange","readyState","LOADING","DONE","Error","onprogress","onerror","aborted","abort","addEventListener","once","send","navigator","product","__DEV__","choices","message","Array","isArray","joined","map","part","join","directText","deltaText","delta","dataText","data","choiceText","rawBody","detail","extractErrorMessage","suffix","error","includes"],"sources":["../../../src/speech-recognition/utils/groq-transcription.ts"],"sourcesContent":["import logger from '../../logger';\n\ntype ReactNativeFile = {\n  uri: string;\n  name?: string;\n  type?: string;\n};\n\nexport type GroqTranscriptionOptions = {\n  apiKey: string;\n  audioBlob: Blob | ReactNativeFile;\n  mimeType: string;\n  language?: string;\n  model?: string;\n  responseFormat?: 'json' | 'verbose_json';\n  stream?: boolean;\n  signal?: AbortSignal;\n  endpoint?: string;\n  onInterim?: (text: string) => void;\n};\n\nconst DEFAULT_ENDPOINT = 'https://api.groq.com/openai/v1/audio/transcriptions';\nconst DEFAULT_TRANSLATION_ENDPOINT =\n  'https://api.groq.com/openai/v1/audio/translations';\nconst DEFAULT_CHAT_COMPLETIONS_ENDPOINT =\n  'https://api.groq.com/openai/v1/chat/completions';\n\nexport type GroqTranslationOptions = {\n  apiKey: string;\n  audioBlob: Blob | ReactNativeFile;\n  mimeType: string;\n  language?: string;\n  model?: string;\n  responseFormat?: 'json' | 'verbose_json';\n  signal?: AbortSignal;\n  endpoint?: string;\n};\n\nexport type GroqTextTranslationOptions = {\n  apiKey: string;\n  text: string;\n  language?: string;\n  targetLanguage?: string;\n  model?: string;\n  signal?: AbortSignal;\n  endpoint?: string;\n};\n\nexport async function streamGroqTranscription({\n  apiKey,\n  audioBlob,\n  mimeType,\n  language = 'en',\n  model = 'whisper-large-v3',\n  responseFormat = 'verbose_json',\n  stream = true,\n  signal,\n  endpoint = DEFAULT_ENDPOINT,\n  onInterim,\n}: GroqTranscriptionOptions): Promise<string> {\n  const fileName = isReactNativeFile(audioBlob)\n    ? audioBlob.name || `audio.${getFileExtension(mimeType)}`\n    : `audio.${getFileExtension(mimeType)}`;\n  const formData = new FormData();\n\n  if (isReactNativeFile(audioBlob)) {\n    formData.append('file', {\n      uri: audioBlob.uri,\n      name: fileName,\n      type: audioBlob.type || mimeType,\n    } as any);\n  } else {\n    const file = createAudioFile(audioBlob, fileName, mimeType);\n    if (file && typeof (file as any) === 'object') {\n      if (file instanceof Blob && !(file as any).name) {\n        formData.append('file', file, fileName);\n      } else {\n        formData.append('file', file as any);\n      }\n    }\n  }\n\n  formData.append('model', model);\n  formData.append('language', language);\n  formData.append('response_format', responseFormat);\n\n  const url = stream ? `${endpoint}?stream=true` : endpoint;\n\n  if (stream && isReactNativeEnv() && typeof XMLHttpRequest !== 'undefined') {\n    logger.warn('[Groq SSE] using XHR streaming (React Native)');\n    return streamGroqTranscriptionViaXhr({\n      apiKey,\n      formData,\n      url,\n      signal,\n      onInterim,\n    });\n  }\n\n  const response = await fetch(url, {\n    method: 'POST',\n    headers: {\n      Authorization: `Bearer ${apiKey}`,\n    },\n    body: formData,\n    signal,\n  });\n\n  if (!response.ok) {\n    const errorBody = await response.text().catch(() => '');\n    throw buildHttpError(response.status, errorBody);\n  }\n\n  let lastText = '';\n\n  const handleLine = (line: string) => {\n    const trimmed = line.trim();\n    if (!trimmed) return;\n\n    const payload = trimmed.startsWith('data:') ? trimmed.slice(5).trim() : trimmed;\n    if (!payload) return;\n\n    try {\n      const parsed = JSON.parse(payload);\n      const text = extractText(parsed);\n      if (text) {\n        lastText = text;\n        if (onInterim) onInterim(text);\n      }\n    } catch {\n      // ignore non-JSON lines\n    }\n  };\n\n  const reader = response.body?.getReader?.();\n  if (reader && typeof TextDecoder !== 'undefined') {\n    const decoder = new TextDecoder();\n    let buffer = '';\n\n    while (true) {\n      const { value, done } = await reader.read();\n      if (done) break;\n      buffer += decoder.decode(value, { stream: true });\n      const lines = buffer.split('\\n');\n      buffer = lines.pop() || '';\n      for (const line of lines) {\n        handleLine(line);\n      }\n    }\n\n    if (buffer) {\n      handleLine(buffer);\n    }\n  } else {\n    const text = await response.text();\n    const lines = text.split('\\n');\n    for (const line of lines) {\n      handleLine(line);\n    }\n  }\n\n  return lastText;\n}\n\nexport async function translateGroqAudio({\n  apiKey,\n  audioBlob,\n  mimeType,\n  language,\n  model = 'whisper-large-v3',\n  responseFormat = 'json',\n  signal,\n  endpoint = DEFAULT_TRANSLATION_ENDPOINT,\n}: GroqTranslationOptions): Promise<string> {\n  const fileName = isReactNativeFile(audioBlob)\n    ? audioBlob.name || `audio.${getFileExtension(mimeType)}`\n    : `audio.${getFileExtension(mimeType)}`;\n  const formData = new FormData();\n\n  if (isReactNativeFile(audioBlob)) {\n    formData.append('file', {\n      uri: audioBlob.uri,\n      name: fileName,\n      type: audioBlob.type || mimeType,\n    } as any);\n  } else {\n    const file = createAudioFile(audioBlob, fileName, mimeType);\n    if (file && typeof (file as any) === 'object') {\n      if (file instanceof Blob && !(file as any).name) {\n        formData.append('file', file, fileName);\n      } else {\n        formData.append('file', file as any);\n      }\n    }\n  }\n\n  formData.append('model', model);\n  if (language) {\n    formData.append('language', language);\n  }\n  formData.append('response_format', responseFormat);\n\n  const response = await fetch(endpoint, {\n    method: 'POST',\n    headers: {\n      Authorization: `Bearer ${apiKey}`,\n    },\n    body: formData,\n    signal,\n  });\n\n  if (!response.ok) {\n    const errorBody = await response.text().catch(() => '');\n    throw buildHttpError(response.status, errorBody);\n  }\n\n  let payload: any = null;\n  try {\n    payload = await response.json();\n  } catch {\n    const text = await response.text().catch(() => '');\n    return text.trim();\n  }\n\n  return extractText(payload);\n}\n\nexport async function translateGroqText({\n  apiKey,\n  text,\n  language,\n  targetLanguage = 'English',\n  model = 'llama-3.1-8b-instant',\n  signal,\n  endpoint = DEFAULT_CHAT_COMPLETIONS_ENDPOINT,\n}: GroqTextTranslationOptions): Promise<string> {\n  const input = text.trim();\n  if (!input) return '';\n\n  const response = await fetch(endpoint, {\n    method: 'POST',\n    headers: {\n      Authorization: 'Bearer ' + apiKey,\n      'Content-Type': 'application/json',\n    },\n    body: JSON.stringify({\n      model,\n      temperature: 0,\n      stream: false,\n      messages: [\n        {\n          role: 'system',\n          content:\n            'Translate user text accurately. Return only translated text without commentary.',\n        },\n        {\n          role: 'user',\n          content: language\n            ? 'Translate from ' + language + ' to ' + targetLanguage + ': ' + input\n            : 'Translate to ' + targetLanguage + ': ' + input,\n        },\n      ],\n    }),\n    signal,\n  });\n\n  if (!response.ok) {\n    const errorBody = await response.text().catch(() => '');\n    throw buildHttpError(response.status, errorBody);\n  }\n\n  const payload = await response.json().catch(() => null);\n  const translated = extractChatCompletionText(payload);\n  if (translated) return translated.trim();\n\n  return extractText(payload);\n}\n\nexport function mergeTranscriptParts(base: string, addition: string): string {\n  const a = base.trim();\n  const b = addition.trim();\n  if (!a) return b;\n  if (!b) return a;\n  if (a.endsWith(b)) return a;\n  if (b.startsWith(a)) return b;\n  return `${a} ${b}`.trim();\n}\n\nfunction createAudioFile(audioBlob: Blob, name: string, mimeType: string): Blob | File {\n  if (typeof File !== 'undefined') {\n    try {\n      return new File([audioBlob], name, { type: mimeType });\n    } catch {\n      return audioBlob;\n    }\n  }\n  return audioBlob;\n}\n\nfunction streamGroqTranscriptionViaXhr(options: {\n  apiKey: string;\n  formData: FormData;\n  url: string;\n  signal?: AbortSignal;\n  onInterim?: (text: string) => void;\n}): Promise<string> {\n  return new Promise((resolve, reject) => {\n    const xhr = new XMLHttpRequest();\n    let lastText = '';\n    let processedLength = 0;\n    let buffer = '';\n    const debug = shouldDebugSse();\n    const log = debug ? logger.warn : logger.debug;\n\n    const handleLine = (line: string) => {\n      const trimmed = line.trim();\n      if (!trimmed) return;\n\n      const payload = trimmed.startsWith('data:') ? trimmed.slice(5).trim() : trimmed;\n      if (!payload) return;\n      if (payload === '[DONE]') return;\n\n      try {\n        const parsed = JSON.parse(payload);\n        const text = extractText(parsed);\n        if (text) {\n          lastText = text;\n          log('[Groq SSE] interim:', text);\n          if (options.onInterim) options.onInterim(text);\n        }\n      } catch {\n        // ignore non-JSON lines\n      }\n    };\n\n    xhr.open('POST', options.url, true);\n    xhr.setRequestHeader('Authorization', `Bearer ${options.apiKey}`);\n    xhr.responseType = 'text';\n\n    const processIncremental = () => {\n      const text = xhr.responseText || '';\n      const chunk = text.slice(processedLength);\n      if (!chunk) return;\n      processedLength = text.length;\n      buffer += chunk;\n      log('[Groq SSE] chunk bytes:', chunk.length);\n\n      const lines = buffer.split('\\n');\n      buffer = lines.pop() || '';\n      for (const line of lines) {\n        handleLine(line);\n      }\n    };\n\n    xhr.onreadystatechange = () => {\n      if (xhr.readyState === XMLHttpRequest.LOADING) {\n        processIncremental();\n        return;\n      }\n      if (xhr.readyState === XMLHttpRequest.DONE) {\n        if (xhr.status >= 200 && xhr.status < 300) {\n          if (buffer) {\n            handleLine(buffer);\n            buffer = '';\n          }\n          processIncremental();\n          resolve(lastText);\n        } else if (xhr.status === 0) {\n          // Status 0 in React Native usually means the request never reached the server\n          reject(\n            new Error(\n              `Groq API network error (status 0). Check device connectivity, HTTP/ATS cleartext settings, and endpoint URL: ${options.url}`\n            )\n          );\n        } else {\n          reject(buildHttpError(xhr.status, xhr.responseText || ''));\n        }\n      }\n    };\n\n    xhr.onprogress = () => {\n      processIncremental();\n    };\n\n    xhr.onerror = () => {\n      reject(new Error('Groq API network error'));\n    };\n\n    if (options.signal) {\n      if (options.signal.aborted) {\n        xhr.abort();\n        reject(new Error('AbortError'));\n        return;\n      }\n      options.signal.addEventListener(\n        'abort',\n        () => {\n          xhr.abort();\n          reject(new Error('AbortError'));\n        },\n        { once: true }\n      );\n    }\n\n    xhr.send(options.formData);\n  });\n}\n\nfunction isReactNativeFile(value: Blob | ReactNativeFile): value is ReactNativeFile {\n  return !!value && typeof value === 'object' && 'uri' in value;\n}\n\nfunction isReactNativeEnv(): boolean {\n  return typeof navigator !== 'undefined' && (navigator as any).product === 'ReactNative';\n}\n\nfunction shouldDebugSse(): boolean {\n  return typeof __DEV__ !== 'undefined' ? __DEV__ : false;\n}\n\nfunction extractChatCompletionText(payload: any): string {\n  const content = payload?.choices?.[0]?.message?.content;\n  if (typeof content === 'string') {\n    return content.trim();\n  }\n  if (Array.isArray(content)) {\n    const joined = content\n      .map((part: any) => {\n        if (typeof part?.text === 'string') return part.text;\n        if (typeof part?.content === 'string') return part.content;\n        return '';\n      })\n      .join('')\n      .trim();\n    return joined;\n  }\n  return '';\n}\n\nfunction extractText(payload: any): string {\n  if (!payload || typeof payload !== 'object') return '';\n  const directText = typeof payload.text === 'string' ? payload.text : '';\n  if (directText) return directText.trim();\n\n  const deltaText =\n    payload.delta && typeof payload.delta.text === 'string'\n      ? payload.delta.text\n      : '';\n  if (deltaText) return deltaText.trim();\n\n  const dataText =\n    payload.data && typeof payload.data.text === 'string'\n      ? payload.data.text\n      : '';\n  if (dataText) return dataText.trim();\n\n  const choiceText =\n    payload.choices?.[0]?.delta?.content ||\n    payload.choices?.[0]?.text ||\n    '';\n  return typeof choiceText === 'string' ? choiceText.trim() : '';\n}\n\nfunction buildHttpError(status: number, rawBody?: string): Error {\n  const detail = extractErrorMessage(rawBody);\n  const suffix = detail ? ` - ${detail}` : '';\n  return new Error(`Groq API error: ${status}${suffix}`);\n}\n\nfunction extractErrorMessage(rawBody?: string): string {\n  if (!rawBody) return '';\n  const trimmed = rawBody.trim();\n  if (!trimmed) return '';\n  try {\n    const parsed = JSON.parse(trimmed);\n    const message =\n      parsed?.error?.message ||\n      parsed?.error ||\n      parsed?.message ||\n      parsed?.detail ||\n      '';\n    if (typeof message === 'string' && message.trim()) {\n      return message.trim();\n    }\n  } catch {\n    // ignore JSON parse failures\n  }\n  return trimmed.slice(0, 300);\n}\n\nfunction getFileExtension(mimeType: string): string {\n  if (mimeType.includes('webm')) return 'webm';\n  if (mimeType.includes('ogg')) return 'ogg';\n  if (mimeType.includes('mp4')) return 'mp4';\n  if (mimeType.includes('wav')) return 'wav';\n  if (mimeType.includes('m4a')) return 'm4a';\n  return 'webm';\n}\n"],"mappings":"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","ignoreList":[]}

package/dist/speech-recognition.d.ts

@@ -0,0 +1,7 @@
+import "regenerator-runtime";
+export declare const SpeechRecognizer: (props: {
+    shouldListen: boolean;
+    speechStatusCallback: (status: boolean, transcript: string) => void;
+    speechResultCallback: (result: string) => void;
+    language?: string;
+}) => any;

package/dist/speech-recognition.js

@@ -0,0 +1,61 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SpeechRecognizer = void 0;
+require("regenerator-runtime");
+var _reactSpeechRecognition = _interopRequireWildcard(require("react-speech-recognition"));
+var _react = _interopRequireWildcard(require("react"));
+var _reactNative = require("react-native");
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+// import createSpeechServicesPonyfill from "web-speech-cognitive-services";
+
+const SpeechRecognizer = props => {
+  const {
+    finalTranscript,
+    interimTranscript,
+    resetTranscript,
+    listening
+  } = (0, _reactSpeechRecognition.useSpeechRecognition)();
+  (0, _react.useEffect)(() => {
+    if (props.shouldListen && !listening) {
+      _reactSpeechRecognition.default.startListening({
+        continuous: true,
+        interimResults: true,
+        language: props.language || "en-US"
+      });
+      return;
+    }
+    if (!props.shouldListen && listening) {
+      _reactSpeechRecognition.default.stopListening();
+    }
+  }, [props.shouldListen, props.language, listening]);
+  (0, _react.useEffect)(() => {
+    props.speechStatusCallback(interimTranscript !== "", interimTranscript);
+  }, [interimTranscript, props.speechStatusCallback]);
+  (0, _react.useEffect)(() => {
+    const trimmedFinal = finalTranscript.trim();
+    if (trimmedFinal !== "") {
+      props.speechResultCallback(trimmedFinal);
+      props.speechStatusCallback(false, "");
+      resetTranscript();
+    }
+  }, [finalTranscript, resetTranscript, props.speechResultCallback, props.speechStatusCallback]);
+
+  // // initialize Azure speech services by creating a ponyfill
+  // useEffect(() => {
+  //   const { SpeechRecognition: AzureSpeechRecognition } =
+  //     createSpeechServicesPonyfill({
+  //       credentials: {
+  //         region: props.azureSpeechRegion,
+  //         subscriptionKey: props.azureSpeechKey,
+  //       },
+  //     });
+  //   SpeechRecognition.applyPolyfill(AzureSpeechRecognition);
+  // }, []);
+
+  return /*#__PURE__*/_react.default.createElement(_reactNative.View, null);
+};
+exports.SpeechRecognizer = SpeechRecognizer;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/voice-pipeline-telemetry.d.ts

@@ -0,0 +1,26 @@
+export type VoicePipelineOutcome = "speech_response_sent" | "speech_response_timeout" | "error" | "aborted";
+export type VoicePipelineStage = "voice.processing" | "stt.listen" | "stt.final_transcript" | "dsl.parse" | "dsl.execute" | "ui.display" | "speech.respond";
+export type VoicePipelineStageStatus = "ok" | "error" | "skipped" | "cancelled";
+export type VoicePipelineContext = {
+    sessionId: number;
+    threadId?: string | null;
+    turnId?: string | null;
+    provider?: string;
+    language?: string;
+    platform?: string;
+};
+export interface VoicePipelineStageHandle {
+    annotate?: (context?: Record<string, unknown>) => void;
+    finish?: (status: VoicePipelineStageStatus, context?: Record<string, unknown>) => void;
+}
+export interface VoicePipelineHandle {
+    annotate?: (context?: Record<string, unknown>) => void;
+    getRequestHeaders?: () => Record<string, string | undefined>;
+    startStage?: (stage: VoicePipelineStage, context?: Record<string, unknown>) => VoicePipelineStageHandle | null | void;
+    finish?: (outcome: VoicePipelineOutcome, context?: Record<string, unknown>) => void;
+}
+export interface VoicePipelineTelemetryBridge {
+    startPipeline?: (context: VoicePipelineContext) => VoicePipelineHandle | null | void;
+}
+export declare function setVoicePipelineTelemetryBridge(bridge?: VoicePipelineTelemetryBridge | null): void;
+export declare function getVoicePipelineTelemetryBridge(): VoicePipelineTelemetryBridge | null;

package/dist/voice-pipeline-telemetry.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getVoicePipelineTelemetryBridge = getVoicePipelineTelemetryBridge;
+exports.setVoicePipelineTelemetryBridge = setVoicePipelineTelemetryBridge;
+let activeVoicePipelineTelemetryBridge = null;
+function setVoicePipelineTelemetryBridge(bridge) {
+  activeVoicePipelineTelemetryBridge = bridge ?? null;
+}
+function getVoicePipelineTelemetryBridge() {
+  return activeVoicePipelineTelemetryBridge;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/metro/index.js

@@ -0,0 +1,3 @@
+module.exports = {
+  withGenieRegistry: require("./with-genie-registry").withGenieRegistry,
+};