@elizaos/plugin-suno 1.0.6-alpha.3 → 2.0.0-beta.1

package/dist/index.js

@@ -1,10 +1,13 @@
 // src/providers/suno.ts
+import {
+  recordLlmCall
+} from "@elizaos/core";
 var SunoProvider = class _SunoProvider {
   apiKey;
   baseUrl;
   static async get(runtime, _message, _state) {
     const apiKey = runtime.getSetting("SUNO_API_KEY");
-    if (!apiKey) {
+    if (typeof apiKey !== "string" || !apiKey) {
       throw new Error("SUNO_API_KEY is required");
     }
     return new _SunoProvider({ apiKey });
@@ -16,425 +19,293 @@ var SunoProvider = class _SunoProvider {
   async get(_runtime, _message, _state) {
     return { status: "ready" };
   }
-  async request(endpoint, options = {}) {
+  async request(runtime, endpoint, options = {}) {
     const url = `${this.baseUrl}${endpoint}`;
     const headers = {
-      "Authorization": `Bearer ${this.apiKey}`,
+      Authorization: `Bearer ${this.apiKey}`,
       "Content-Type": "application/json",
       ...options.headers
     };
-    const response = await fetch(url, {
-      ...options,
-      headers
+    const body = typeof options.body === "string" ? options.body : "";
+    const details = {
+      model: "suno",
+      modelVersion: "api-v1",
+      systemPrompt: "Suno music generation API request",
+      userPrompt: body,
+      temperature: readTemperature(body),
+      maxTokens: 0,
+      purpose: "action",
+      actionType: `suno.fetch${endpoint}`
+    };
+    return recordLlmCall(runtime, details, async () => {
+      const response = await fetch(url, {
+        ...options,
+        headers
+      });
+      if (!response.ok) {
+        throw new Error(`Suno API error: ${response.statusText}`);
+      }
+      const data = await response.json();
+      details.response = JSON.stringify({ suno_response: data });
+      return data;
     });
-    if (!response.ok) {
-      throw new Error(`Suno API error: ${response.statusText}`);
-    }
-    return response.json();
+  }
+};
+function readTemperature(body) {
+  if (!body) return 0;
+  try {
+    const parsed = JSON.parse(body);
+    return typeof parsed.temperature === "number" ? parsed.temperature : 0;
+  } catch {
+    return 0;
+  }
+}
+var sunoStatusProvider = {
+  name: "SUNO_STATUS",
+  description: "Suno music generation status",
+  descriptionCompressed: "Suno generation availability.",
+  contexts: ["media"],
+  contextGate: { anyOf: ["media"] },
+  cacheStable: false,
+  cacheScope: "turn",
+  get: async (runtime) => {
+    const configured = Boolean(runtime.getSetting("SUNO_API_KEY"));
+    return {
+      text: JSON.stringify(
+        {
+          suno: {
+            configured,
+            status: configured ? "ready" : "missing_api_key",
+            action: "MUSIC_GENERATION",
+            subactions: ["generate", "custom", "extend"]
+          }
+        },
+        null,
+        2
+      ),
+      data: { configured },
+      values: { sunoConfigured: configured }
+    };
   }
 };
 
-// src/actions/generate.ts
-var generateMusic = {
-  name: "generate-music",
-  description: "Generate music using Suno AI",
+// src/actions/musicGeneration.ts
+var SUNO_ACTION_TIMEOUT_MS = 3e4;
+var MAX_SUNO_RESPONSE_BYTES = 4e3;
+function paramsFromMessageAndOptions(message, options) {
+  const content = message.content && typeof message.content === "object" ? message.content : {};
+  const parameters = (options == null ? void 0 : options.parameters) && typeof options.parameters === "object" ? options.parameters : {};
+  return { ...content, ...options, ...parameters };
+}
+function normalizeSubaction(value) {
+  const normalized = typeof value === "string" ? value.trim().toLowerCase() : "";
+  if (normalized === "generate" || normalized === "custom" || normalized === "extend") {
+    return normalized;
+  }
+  if (normalized === "custom_generate" || normalized === "custom-generate") return "custom";
+  if (normalized === "extend_audio" || normalized === "extend-audio") return "extend";
+  return null;
+}
+function inferSubaction(message, params) {
+  var _a;
+  const explicit = normalizeSubaction(params.action ?? params.subaction ?? params.operation);
+  if (explicit) return explicit;
+  const text = (((_a = message.content) == null ? void 0 : _a.text) ?? "").toLowerCase();
+  if (params.audio_id || /\b(extend|lengthen|longer|add \d+.*seconds?)\b/.test(text)) {
+    return "extend";
+  }
+  if (params.reference_audio || params.style || params.bpm || params.key || params.mode || /\b(custom|style|bpm|key|mode|reference)\b/.test(text)) {
+    return "custom";
+  }
+  return "generate";
+}
+function promptFromParams(message, params) {
+  var _a;
+  const prompt = typeof params.prompt === "string" ? params.prompt.trim() : "";
+  if (prompt) return prompt;
+  return (((_a = message.content) == null ? void 0 : _a.text) ?? "").trim();
+}
+function numberOrDefault(value, fallback) {
+  return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+function generationBody(params, prompt) {
+  return {
+    prompt,
+    duration: numberOrDefault(params.duration, 30),
+    temperature: numberOrDefault(params.temperature, 1),
+    top_k: numberOrDefault(params.topK, 250),
+    top_p: numberOrDefault(params.topP, 0.95),
+    classifier_free_guidance: numberOrDefault(params.classifier_free_guidance, 3)
+  };
+}
+var musicGeneration = {
+  name: "MUSIC_GENERATION",
+  contexts: ["media"],
+  contextGate: { anyOf: ["media"] },
+  roleGate: { minRole: "USER" },
+  description: "Generate music through Suno. Use action generate for a simple prompt, custom for style/BPM/key/reference parameters, or extend for an existing audio_id and duration.",
+  descriptionCompressed: "Suno music generation router action: generate, custom, extend.",
   similes: [
+    "GENERATE_MUSIC",
     "CREATE_MUSIC",
     "MAKE_MUSIC",
     "COMPOSE_MUSIC",
-    "GENERATE_AUDIO",
-    "CREATE_SONG",
-    "MAKE_SONG"
+    "CUSTOM_GENERATE_MUSIC",
+    "EXTEND_AUDIO"
   ],
-  validate: async (runtime, _message) => {
-    return !!runtime.getSetting("SUNO_API_KEY");
-  },
-  handler: async (runtime, message, state, _options, callback) => {
-    try {
-      const provider = await SunoProvider.get(runtime, message, state);
-      const content = message.content;
-      if (!content.prompt) {
-        throw new Error("Missing required parameter: prompt");
-      }
-      const response = await provider.request("/generate", {
-        method: "POST",
-        body: JSON.stringify({
-          prompt: content.prompt,
-          duration: content.duration || 30,
-          temperature: content.temperature || 1,
-          top_k: content.topK || 250,
-          top_p: content.topP || 0.95,
-          classifier_free_guidance: content.classifier_free_guidance || 3
-        })
-      });
-      if (callback) {
-        callback({
-          text: "Successfully generated music based on your prompt",
-          content: response
-        });
-      }
-      return true;
-    } catch (error) {
-      if (callback) {
-        callback({
-          text: `Failed to extend audio: ${error.message}`,
-          error
-        });
-      }
-      return false;
+  parameters: [
+    {
+      name: "action",
+      description: "Suno operation: generate, custom, or extend.",
+      required: false,
+      schema: { type: "string", enum: ["generate", "custom", "extend"] }
+    },
+    {
+      name: "subaction",
+      description: "Legacy alias for action.",
+      required: false,
+      schema: { type: "string" }
+    },
+    {
+      name: "prompt",
+      description: "Music prompt for generate/custom.",
+      required: false,
+      schema: { type: "string" }
+    },
+    {
+      name: "audio_id",
+      description: "Existing Suno audio id for extend.",
+      required: false,
+      schema: { type: "string" }
+    },
+    {
+      name: "duration",
+      description: "Generation duration or extension seconds.",
+      required: false,
+      schema: { type: "number", default: 30 }
     }
-  },
-  examples: [
-    [
-      {
-        user: "{{user1}}",
-        content: {
-          text: "Create a happy and energetic song",
-          prompt: "A cheerful and energetic melody with upbeat rhythm",
-          duration: 30,
-          temperature: 1
-        }
-      },
-      {
-        user: "{{agent}}",
-        content: {
-          text: "I'll generate a happy and energetic song for you.",
-          action: "generate-music"
-        }
-      },
-      {
-        user: "{{agent}}",
-        content: {
-          text: "Successfully generated your upbeat and energetic song."
-        }
-      }
-    ],
-    [
-      {
-        user: "{{user1}}",
-        content: {
-          text: "Generate a relaxing ambient track",
-          prompt: "A peaceful ambient soundscape with gentle waves and soft pads",
-          duration: 45,
-          temperature: 0.8,
-          classifier_free_guidance: 4
-        }
-      },
-      {
-        user: "{{agent}}",
-        content: {
-          text: "I'll create a calming ambient piece for you.",
-          action: "generate-music"
-        }
-      },
-      {
-        user: "{{agent}}",
-        content: {
-          text: "Successfully generated your relaxing ambient soundscape."
-        }
-      }
-    ],
-    [
-      {
-        user: "{{user1}}",
-        content: {
-          text: "Make a short jingle for my podcast",
-          prompt: "A catchy and professional podcast intro jingle",
-          duration: 15,
-          temperature: 1.2,
-          top_k: 300
-        }
-      },
-      {
-        user: "{{agent}}",
-        content: {
-          text: "I'll generate a podcast jingle for you.",
-          action: "generate-music"
-        }
-      },
-      {
-        user: "{{agent}}",
-        content: {
-          text: "Successfully generated your podcast jingle."
-        }
-      }
-    ]
-  ]
-};
-var generate_default = generateMusic;
-
-// src/actions/customGenerate.ts
-var customGenerateMusic = {
-  name: "custom-generate-music",
-  description: "Generate music with custom parameters using Suno AI",
-  similes: [
-    "CREATE_CUSTOM_MUSIC",
-    "GENERATE_CUSTOM_AUDIO",
-    "MAKE_CUSTOM_MUSIC",
-    "COMPOSE_CUSTOM_MUSIC",
-    "COMPOSE_MUSIC",
-    "CREATE_MUSIC",
-    "GENERATE_MUSIC"
   ],
-  validate: async (runtime, _message) => {
-    return !!runtime.getSetting("SUNO_API_KEY");
+  validate: async (runtime, message) => {
+    var _a;
+    if (!runtime.getSetting("SUNO_API_KEY")) return false;
+    const text = (((_a = message.content) == null ? void 0 : _a.text) ?? "").toLowerCase();
+    return /\b(generate|create|make|compose|extend|music|song|audio|track)\b/.test(text);
   },
-  handler: async (runtime, message, state, _options, callback) => {
+  handler: async (runtime, message, state, options, callback) => {
     try {
+      const params = paramsFromMessageAndOptions(message, options);
+      const subaction = inferSubaction(message, params);
       const provider = await SunoProvider.get(runtime, message, state);
-      const content = message.content;
-      if (!content.prompt) {
-        throw new Error("Missing required parameter: prompt");
-      }
-      const response = await provider.request("/custom-generate", {
-        method: "POST",
-        body: JSON.stringify({
-          prompt: content.prompt,
-          duration: content.duration || 30,
-          temperature: content.temperature || 1,
-          top_k: content.topK || 250,
-          top_p: content.topP || 0.95,
-          classifier_free_guidance: content.classifier_free_guidance || 3,
-          reference_audio: content.reference_audio,
-          style: content.style,
-          bpm: content.bpm,
-          key: content.key,
-          mode: content.mode
-        })
-      });
-      if (callback) {
-        callback({
-          text: "Successfully generated custom music",
-          content: response
-        });
-      }
-      return true;
-    } catch (error) {
-      if (callback) {
-        callback({
-          text: `Failed to generate custom music: ${error.message}`,
-          error
-        });
-      }
-      return false;
-    }
-  },
-  examples: [
-    [
-      {
-        user: "{{user1}}",
-        content: {
-          text: "Create an upbeat electronic dance track with heavy bass",
-          prompt: "An upbeat electronic dance track with heavy bass and energetic synths",
-          duration: 60,
-          style: "electronic",
-          bpm: 128
-        }
-      },
-      {
-        user: "{{agent}}",
-        content: {
-          text: "I'll generate an energetic EDM track for you.",
-          action: "custom-generate-music"
-        }
-      },
-      {
-        user: "{{agent}}",
-        content: {
-          text: "Successfully generated your EDM track with heavy bass and synths."
-        }
-      }
-    ],
-    [
-      {
-        user: "{{user1}}",
-        content: {
-          text: "Generate a calm piano melody in C major",
-          prompt: "A gentle, flowing piano melody with soft dynamics",
-          duration: 45,
-          style: "classical",
-          key: "C",
-          mode: "major",
-          temperature: 0.8
-        }
-      },
-      {
-        user: "{{agent}}",
-        content: {
-          text: "I'll create a calming piano piece in C major for you.",
-          action: "custom-generate-music"
-        }
-      },
-      {
-        user: "{{agent}}",
-        content: {
-          text: "Successfully generated your peaceful piano melody in C major."
-        }
-      }
-    ],
-    [
-      {
-        user: "{{user1}}",
-        content: {
-          text: "Make a rock song with guitar solos",
-          prompt: "A rock song with powerful electric guitar solos and driving drums",
-          duration: 90,
-          style: "rock",
-          bpm: 120,
-          classifier_free_guidance: 4
+      let endpoint = "/generate";
+      let body;
+      if (subaction === "extend") {
+        if (!params.audio_id || !params.duration) {
+          throw new Error("Missing required parameters: audio_id and duration");
         }
-      },
-      {
-        user: "{{agent}}",
-        content: {
-          text: "I'll generate a rock track with guitar solos for you.",
-          action: "custom-generate-music"
+        endpoint = "/extend";
+        body = {
+          audio_id: params.audio_id,
+          duration: params.duration
+        };
+      } else {
+        const prompt = promptFromParams(message, params);
+        if (!prompt) {
+          throw new Error("Missing required parameter: prompt");
         }
-      },
-      {
-        user: "{{agent}}",
-        content: {
-          text: "Successfully generated your rock song with guitar solos."
+        body = generationBody(params, prompt);
+        if (subaction === "custom") {
+          endpoint = "/custom-generate";
+          body = {
+            ...body,
+            reference_audio: params.reference_audio,
+            style: params.style,
+            bpm: params.bpm,
+            key: params.key,
+            mode: params.mode
+          };
         }
       }
-    ]
-  ]
-};
-var customGenerate_default = customGenerateMusic;
-
-// src/actions/extend.ts
-var extendAudio = {
-  name: "extend-audio",
-  description: "Extend the duration of an existing audio generation",
-  similes: [
-    "LENGTHEN_AUDIO",
-    "PROLONG_AUDIO",
-    "INCREASE_DURATION",
-    "MAKE_AUDIO_LONGER"
-  ],
-  validate: async (runtime, _message) => {
-    return !!runtime.getSetting("SUNO_API_KEY");
-  },
-  handler: async (runtime, message, state, _options, callback) => {
-    try {
-      const provider = await SunoProvider.get(runtime, message, state);
-      const content = message.content;
-      if (!content.audio_id || !content.duration) {
-        throw new Error("Missing required parameters: audio_id and duration");
-      }
-      const response = await provider.request("/extend", {
+      const controller = new AbortController();
+      const timeout = setTimeout(() => controller.abort(), SUNO_ACTION_TIMEOUT_MS);
+      const response = await provider.request(runtime, endpoint, {
         method: "POST",
-        body: JSON.stringify({
-          audio_id: content.audio_id,
-          duration: content.duration
-        })
-      });
-      if (callback) {
-        callback({
-          text: `Successfully extended audio ${content.audio_id}`,
-          content: response
-        });
-      }
-      return true;
+        body: JSON.stringify(body),
+        signal: controller.signal
+      }).finally(() => clearTimeout(timeout));
+      const cappedResponse = JSON.stringify(response).length > MAX_SUNO_RESPONSE_BYTES ? {
+        truncated: true,
+        preview: JSON.stringify(response).slice(0, MAX_SUNO_RESPONSE_BYTES)
+      } : response;
+      await (callback == null ? void 0 : callback({
+        text: subaction === "extend" ? `Successfully extended audio ${params.audio_id}` : `Successfully submitted ${subaction} music generation`,
+        content: cappedResponse
+      }));
+      return {
+        success: true,
+        text: subaction === "extend" ? `Successfully extended audio ${params.audio_id}` : `Successfully submitted ${subaction} music generation`,
+        data: { subaction, response: cappedResponse }
+      };
     } catch (error) {
-      if (callback) {
-        callback({
-          text: `Failed to extend audio: ${error.message}`,
-          error
-        });
-      }
-      return false;
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      const text = `Music generation failed: ${errorMessage}`;
+      await (callback == null ? void 0 : callback({
+        text,
+        error
+      }));
+      return { success: false, text, error: errorMessage };
     }
   },
   examples: [
     [
       {
-        user: "{{user1}}",
-        content: {
-          text: "Make this song longer by 30 seconds",
-          audio_id: "abc123",
-          duration: 30
-        }
-      },
-      {
-        user: "{{agent}}",
-        content: {
-          text: "I'll extend your song by 30 seconds.",
-          action: "extend-audio"
-        }
-      },
-      {
-        user: "{{agent}}",
-        content: {
-          text: "Successfully extended your song by 30 seconds."
-        }
-      }
-    ],
-    [
-      {
-        user: "{{user1}}",
-        content: {
-          text: "Double the length of this track",
-          audio_id: "xyz789",
-          duration: 60
-        }
-      },
-      {
-        user: "{{agent}}",
-        content: {
-          text: "I'll double the duration of your track.",
-          action: "extend-audio"
-        }
-      },
-      {
-        user: "{{agent}}",
-        content: {
-          text: "Successfully doubled the length of your track to 60 seconds."
-        }
-      }
-    ],
-    [
-      {
-        user: "{{user1}}",
-        content: {
-          text: "Add 15 more seconds to this melody",
-          audio_id: "def456",
-          duration: 15
-        }
-      },
-      {
-        user: "{{agent}}",
+        name: "{{user1}}",
         content: {
-          text: "I'll add 15 seconds to your melody.",
-          action: "extend-audio"
+          text: "Generate a relaxing ambient track",
+          prompt: "A peaceful ambient soundscape with gentle waves and soft pads",
+          duration: 45
         }
       },
       {
-        user: "{{agent}}",
+        name: "{{agent}}",
         content: {
-          text: "Successfully added 15 seconds to your melody."
+          text: "I'll generate a calming ambient piece.",
+          action: "MUSIC_GENERATION"
         }
       }
     ]
   ]
 };
-var extend_default = extendAudio;
+var musicGeneration_default = musicGeneration;
 
 // src/index.ts
 var sunoPlugin = {
   name: "suno",
   description: "Suno AI Music Generation Plugin for Eliza",
-  actions: [generate_default, customGenerate_default, extend_default],
-  evaluators: [],
-  providers: [SunoProvider]
+  actions: [musicGeneration_default],
+  providers: [sunoStatusProvider],
+  // Self-declared auto-enable: activate when SUNO_API_KEY is set OR when
+  // media.audio is configured to use the suno provider with own-key mode.
+  autoEnable: {
+    shouldEnable: (env, config) => {
+      const key = env.SUNO_API_KEY;
+      if (typeof key === "string" && key.trim() !== "") return true;
+      const media = config == null ? void 0 : config.media;
+      const audio = media == null ? void 0 : media.audio;
+      return Boolean(
+        audio && audio.enabled !== false && audio.mode === "own-key" && audio.provider === "suno"
+      );
+    }
+  }
 };
 var index_default = sunoPlugin;
 export {
-  customGenerate_default as CustomGenerateMusic,
-  extend_default as ExtendAudio,
-  generate_default as GenerateMusic,
+  musicGeneration_default as CustomGenerateMusic,
+  musicGeneration_default as ExtendAudio,
+  musicGeneration_default as GenerateMusic,
+  musicGeneration_default as MusicGeneration,
   SunoProvider,
   index_default as default,
-  sunoPlugin
+  sunoPlugin,
+  sunoStatusProvider
 };
 //# sourceMappingURL=index.js.map