@elizaos/plugin-elevenlabs 1.5.13 → 1.6.0

package/dist/cjs/index.node.cjs

@@ -99814,7 +99814,7 @@ module.exports = __toCommonJS(exports_index_node);
 
 // src/index.ts
 var import_core = require("@elizaos/core");
-var import_elevenlabs_js = __toESM(require_elevenlabs_js());
+var import_elevenlabs_js = __toESM(require_elevenlabs_js(), 1);
 function isBrowser() {
   return typeof globalThis !== "undefined" && typeof globalThis.document !== "undefined";
 }
@@ -99842,7 +99842,20 @@ function getVoiceSettings(runtime) {
     outputFormat: getSetting(runtime, "ELEVENLABS_OUTPUT_FORMAT", "mp3_44100_128"),
     similarity: getSetting(runtime, "ELEVENLABS_VOICE_SIMILARITY_BOOST", "0.75"),
     style: getSetting(runtime, "ELEVENLABS_VOICE_STYLE", "0"),
-    speakerBoost: import_core.parseBooleanFromText(getSetting(runtime, "ELEVENLABS_VOICE_USE_SPEAKER_BOOST", "true") + "")
+    speakerBoost: import_core.parseBooleanFromText(`${getSetting(runtime, "ELEVENLABS_VOICE_USE_SPEAKER_BOOST", "true")}`)
+  };
+}
+function getTranscriptionSettings(runtime) {
+  const languageCode = getSetting(runtime, "ELEVENLABS_STT_LANGUAGE_CODE");
+  const numSpeakersStr = getSetting(runtime, "ELEVENLABS_STT_NUM_SPEAKERS");
+  return {
+    apiKey: getApiKey(runtime) || "",
+    modelId: getSetting(runtime, "ELEVENLABS_STT_MODEL_ID", "scribe_v1"),
+    languageCode: languageCode || undefined,
+    timestampsGranularity: getSetting(runtime, "ELEVENLABS_STT_TIMESTAMPS_GRANULARITY", "word"),
+    diarize: import_core.parseBooleanFromText(`${getSetting(runtime, "ELEVENLABS_STT_DIARIZE", "false")}`),
+    numSpeakers: numSpeakersStr ? Number(numSpeakersStr) : undefined,
+    tagAudioEvents: import_core.parseBooleanFromText(`${getSetting(runtime, "ELEVENLABS_STT_TAG_AUDIO_EVENTS", "false")}`)
   };
 }
 async function fetchSpeech(runtime, params) {
@@ -99875,9 +99888,56 @@ async function fetchSpeech(runtime, params) {
     throw error instanceof Error ? error : new Error(msg);
   }
 }
+async function fetchTranscription(runtime, params) {
+  try {
+    const baseUrl = getBaseURL(runtime);
+    const apiKey = getApiKey(runtime) ?? (isBrowser() ? "sk-proxy" : undefined);
+    const client = new import_elevenlabs_js.ElevenLabsClient({
+      apiKey,
+      baseUrl
+    });
+    const requestParams = {
+      modelId: params.modelId,
+      audio: params.audioFile
+    };
+    if (params.languageCode) {
+      requestParams.languageCode = params.languageCode;
+    }
+    if (params.timestampsGranularity !== "none") {
+      requestParams.timestampsGranularity = params.timestampsGranularity;
+    }
+    if (params.diarize) {
+      requestParams.diarize = true;
+      if (params.numSpeakers) {
+        requestParams.numSpeakers = params.numSpeakers;
+      }
+    }
+    if (params.tagAudioEvents) {
+      requestParams.tagAudioEvents = true;
+    }
+    const response = await client.speechToText.convert(requestParams);
+    if (!response) {
+      throw new Error("Empty response from ElevenLabs STT API");
+    }
+    let transcript = "";
+    if ("transcript" in response && response.transcript) {
+      const transcriptObj = response.transcript;
+      transcript = transcriptObj.text || "";
+    } else if ("transcripts" in response && response.transcripts) {
+      const transcriptsArray = response.transcripts;
+      transcript = transcriptsArray.map((t) => t.text || "").join(`
+`);
+    }
+    return transcript;
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    import_core.logger.error(`ElevenLabs fetchTranscription error: ${msg}`);
+    throw error instanceof Error ? error : new Error(msg);
+  }
+}
 var elevenLabsPlugin = {
   name: "elevenLabs",
-  description: "High-quality text-to-speech synthesis using ElevenLabs API with support for multiple voices and languages",
+  description: "High-quality text-to-speech synthesis and speech-to-text transcription using ElevenLabs API with support for multiple voices, languages, and speaker diarization",
   models: {
     [import_core.ModelType.TEXT_TO_SPEECH]: async (runtime, input) => {
       const options = typeof input === "string" ? { text: input } : input;
@@ -99904,6 +99964,46 @@ var elevenLabsPlugin = {
         import_core.logger.error(`ElevenLabs model error: ${msg}`);
         throw error instanceof Error ? error : new Error(msg);
       }
+    },
+    [import_core.ModelType.TRANSCRIPTION]: async (runtime, input) => {
+      const settings = getTranscriptionSettings(runtime);
+      import_core.logger.log(`[ElevenLabs] Using TRANSCRIPTION model: ${settings.modelId}`);
+      try {
+        let audioFile;
+        if (typeof input === "string") {
+          const response = await fetch(input);
+          if (!response.ok) {
+            throw new Error(`Failed to fetch audio from URL: ${input}`);
+          }
+          const arrayBuffer = await response.arrayBuffer();
+          audioFile = Buffer.from(arrayBuffer);
+        } else if (Buffer.isBuffer(input)) {
+          audioFile = input;
+        } else if (typeof input === "object" && "audioUrl" in input) {
+          const response = await fetch(input.audioUrl);
+          if (!response.ok) {
+            throw new Error(`Failed to fetch audio from URL: ${input.audioUrl}`);
+          }
+          const arrayBuffer = await response.arrayBuffer();
+          audioFile = Buffer.from(arrayBuffer);
+        } else {
+          throw new Error("Invalid input type for TRANSCRIPTION model");
+        }
+        const transcript = await fetchTranscription(runtime, {
+          audioFile,
+          modelId: settings.modelId,
+          languageCode: settings.languageCode,
+          timestampsGranularity: settings.timestampsGranularity,
+          diarize: settings.diarize,
+          numSpeakers: settings.numSpeakers,
+          tagAudioEvents: settings.tagAudioEvents
+        });
+        return transcript;
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        import_core.logger.error(`ElevenLabs transcription error: ${msg}`);
+        throw error instanceof Error ? error : new Error(msg);
+      }
     }
   },
   tests: [
@@ -99926,12 +100026,12 @@ var elevenLabsPlugin = {
             if (!settings.voiceId) {
               throw new Error("Missing voice ID configuration");
             }
-            const stability = parseFloat(settings.stability);
-            if (isNaN(stability) || stability < 0 || stability > 1) {
+            const stability = Number.parseFloat(settings.stability);
+            if (Number.isNaN(stability) || stability < 0 || stability > 1) {
               throw new Error("Voice stability must be between 0 and 1");
             }
-            const similarity = parseFloat(settings.similarity);
-            if (isNaN(similarity) || similarity < 0 || similarity > 1) {
+            const similarity = Number.parseFloat(settings.similarity);
+            if (Number.isNaN(similarity) || similarity < 0 || similarity > 1) {
               throw new Error("Voice similarity boost must be between 0 and 1");
             }
             import_core.logger.success("Voice settings validated successfully");
@@ -100015,7 +100115,7 @@ var elevenLabsPlugin = {
             for (const format of pcmFormats) {
               if (format.startsWith("pcm_")) {
                 const sampleRate = Number.parseInt(format.slice(4));
-                if (isNaN(sampleRate) || sampleRate <= 0) {
+                if (Number.isNaN(sampleRate) || sampleRate <= 0) {
                   throw new Error(`Invalid PCM format: ${format}`);
                 }
               }
@@ -100024,9 +100124,60 @@ var elevenLabsPlugin = {
           }
         }
       ]
+    },
+    {
+      name: "test eleven labs STT",
+      tests: [
+        {
+          name: "STT settings validation",
+          fn: async (runtime) => {
+            const settings = getTranscriptionSettings(runtime);
+            if (!settings.modelId) {
+              throw new Error("Missing STT model ID configuration");
+            }
+            const validGranularities = ["none", "word", "character"];
+            if (!validGranularities.includes(settings.timestampsGranularity)) {
+              throw new Error(`Invalid timestamps granularity: ${settings.timestampsGranularity}`);
+            }
+            if (settings.numSpeakers !== undefined && (settings.numSpeakers < 1 || settings.numSpeakers > 32)) {
+              throw new Error("Number of speakers must be between 1 and 32");
+            }
+            import_core.logger.success("STT settings validated successfully");
+          }
+        },
+        {
+          name: "STT configuration defaults",
+          fn: async (runtime) => {
+            const settings = getTranscriptionSettings(runtime);
+            if (settings.modelId !== "scribe_v1") {
+              import_core.logger.warn(`Using non-default STT model: ${settings.modelId}`);
+            }
+            if (settings.timestampsGranularity !== "word") {
+              import_core.logger.warn(`Using non-default timestamps granularity: ${settings.timestampsGranularity}`);
+            }
+            import_core.logger.success("STT configuration defaults checked");
+          }
+        },
+        {
+          name: "STT input handling validation",
+          fn: async (runtime) => {
+            const testCases = [
+              { type: "string URL", valid: true },
+              { type: "Buffer", valid: true },
+              { type: "object with audioUrl", valid: true }
+            ];
+            for (const testCase of testCases) {
+              if (!testCase.valid) {
+                throw new Error(`Invalid test case should not be valid: ${testCase.type}`);
+              }
+            }
+            import_core.logger.success("STT input handling validation passed");
+          }
+        }
+      ]
     }
   ]
 };
 var src_default = elevenLabsPlugin;
 
-//# debugId=AD5D1D13D464100B64756E2164756E21
+//# debugId=F8EB9AB5C99014D864756E2164756E21