@elizaos/plugin-suno 1.0.5 → 1.0.6-alpha.1

package/src/actions/customGenerate.ts

@@ -0,0 +1,156 @@
+import type { Action, IAgentRuntime, Memory, State, HandlerCallback } from "@elizaos/core";
+import { SunoProvider } from "../providers/suno";
+import type { CustomGenerateParams } from "../types";
+
+const customGenerateMusic: Action = {
+    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: IAgentRuntime, _message: Memory) => {
+        return !!runtime.getSetting("SUNO_API_KEY");
+    },
+
+    handler: async (
+        runtime: IAgentRuntime,
+        message: Memory,
+        state: State,
+        _options: { [key: string]: unknown },
+        callback?: HandlerCallback
+    ): Promise<boolean> => {
+        try {
+            const provider = await SunoProvider.get(runtime, message, state);
+            const content = message.content as unknown as CustomGenerateParams;
+
+            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.0,
+                    top_k: content.topK || 250,
+                    top_p: content.topP || 0.95,
+                    classifier_free_guidance: content.classifier_free_guidance || 3.0,
+                    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 as Error).message}`,
+                    error: 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.0
+                }
+            },
+            {
+                user: "{{agent}}",
+                content: {
+                    text: "I'll generate a rock track with guitar solos for you.",
+                    action: "custom-generate-music"
+                }
+            },
+            {
+                user: "{{agent}}",
+                content: {
+                    text: "Successfully generated your rock song with guitar solos."
+                }
+            }
+        ]
+    ]
+};
+
+export default customGenerateMusic;

package/src/actions/extend.ts

@@ -0,0 +1,134 @@
+import type { Action, IAgentRuntime, Memory, State, HandlerCallback } from "@elizaos/core";
+import { SunoProvider } from "../providers/suno";
+import type { ExtendParams } from "../types";
+
+const extendAudio: Action = {
+    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: IAgentRuntime, _message: Memory) => {
+        return !!runtime.getSetting("SUNO_API_KEY");
+    },
+
+    handler: async (
+        runtime: IAgentRuntime,
+        message: Memory,
+        state: State,
+        _options: { [key: string]: unknown },
+        callback?: HandlerCallback
+    ): Promise<boolean> => {
+        try {
+            const provider = await SunoProvider.get(runtime, message, state);
+            const content = message.content as unknown as ExtendParams;
+
+            if (!content.audio_id || !content.duration) {
+                throw new Error("Missing required parameters: audio_id and duration");
+            }
+
+            const response = await provider.request('/extend', {
+                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;
+        } catch (error) {
+            if (callback) {
+                callback({
+                    text: `Failed to extend audio: ${(error as Error).message}`,
+                    error: error
+                });
+            }
+            return false;
+        }
+    },
+
+    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}}",
+                content: {
+                    text: "I'll add 15 seconds to your melody.",
+                    action: "extend-audio"
+                }
+            },
+            {
+                user: "{{agent}}",
+                content: {
+                    text: "Successfully added 15 seconds to your melody."
+                }
+            }
+        ]
+    ]
+};
+
+export default extendAudio;

package/src/actions/generate.ts

@@ -0,0 +1,145 @@
+import type { Action, IAgentRuntime, Memory, State, HandlerCallback } from "@elizaos/core";
+import { SunoProvider } from "../providers/suno";
+import type { GenerateParams } from "../types";
+
+const generateMusic: Action = {
+    name: "generate-music",
+    description: "Generate music using Suno AI",
+    similes: [
+        "CREATE_MUSIC",
+        "MAKE_MUSIC",
+        "COMPOSE_MUSIC",
+        "GENERATE_AUDIO",
+        "CREATE_SONG",
+        "MAKE_SONG"
+    ],
+
+    validate: async (runtime: IAgentRuntime, _message: Memory) => {
+        return !!runtime.getSetting("SUNO_API_KEY");
+    },
+
+    handler: async (
+        runtime: IAgentRuntime,
+        message: Memory,
+        state: State,
+        _options: { [key: string]: unknown },
+        callback?: HandlerCallback
+    ): Promise<boolean> => {
+        try {
+            const provider = await SunoProvider.get(runtime, message, state);
+            const content = message.content as unknown as GenerateParams;
+
+            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.0,
+                    top_k: content.topK || 250,
+                    top_p: content.topP || 0.95,
+                    classifier_free_guidance: content.classifier_free_guidance || 3.0
+                })
+            });
+
+            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 as Error).message}`,
+                    error: error
+                });
+            }
+            return false;
+        }
+    },
+
+    examples: [
+        [
+            {
+                user: "{{user1}}",
+                content: {
+                    text: "Create a happy and energetic song",
+                    prompt: "A cheerful and energetic melody with upbeat rhythm",
+                    duration: 30,
+                    temperature: 1.0
+                }
+            },
+            {
+                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.0
+                }
+            },
+            {
+                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."
+                }
+            }
+        ]
+    ]
+};
+
+export default generateMusic;

package/src/index.ts

@@ -0,0 +1,22 @@
+import type { Plugin } from "@elizaos/core";
+import generateMusic from "./actions/generate";
+import customGenerateMusic from "./actions/customGenerate";
+import extendAudio from "./actions/extend";
+import { SunoProvider } from "./providers/suno";
+
+export {
+    SunoProvider,
+    generateMusic as GenerateMusic,
+    customGenerateMusic as CustomGenerateMusic,
+    extendAudio as ExtendAudio
+};
+
+export const sunoPlugin: Plugin = {
+    name: "suno",
+    description: "Suno AI Music Generation Plugin for Eliza",
+    actions: [generateMusic, customGenerateMusic, extendAudio],
+    evaluators: [],
+    providers: [SunoProvider],
+};
+
+export default sunoPlugin;

package/src/providers/suno.ts

@@ -0,0 +1,78 @@
+import type { IAgentRuntime, Memory, State } from "@elizaos/core";  // Added type keyword
+import type { Provider } from "@elizaos/core";  // Added type keyword
+
+export interface SunoConfig {
+    apiKey: string;
+    baseUrl?: string;
+}
+
+export class SunoProvider implements Provider {
+    private apiKey: string;
+    private baseUrl: string;
+
+    static async get(runtime: IAgentRuntime, _message: Memory, _state?: State): Promise<SunoProvider> {
+        const apiKey = runtime.getSetting("SUNO_API_KEY");
+        if (!apiKey) {
+            throw new Error("SUNO_API_KEY is required");
+        }
+        return new SunoProvider({ apiKey });
+    }
+
+    constructor(config: SunoConfig) {
+        this.apiKey = config.apiKey;
+        this.baseUrl = config.baseUrl || 'https://api.suno.ai/v1';
+    }
+
+    async get(_runtime: IAgentRuntime, _message: Memory, _state?: State): Promise<{ status: string }> {
+        return { status: 'ready' };
+    }
+
+    async request(endpoint: string, options: RequestInit = {}) {
+        const url = `${this.baseUrl}${endpoint}`;
+        const headers = {
+            'Authorization': `Bearer ${this.apiKey}`,
+            'Content-Type': 'application/json',
+            ...options.headers,
+        };
+
+        const response = await fetch(url, {
+            ...options,
+            headers,
+        });
+
+        if (!response.ok) {
+            throw new Error(`Suno API error: ${response.statusText}`);
+        }
+
+        return response.json();
+    }
+}
+
+export interface GenerateParams {
+    prompt: string;
+    duration?: number;
+    temperature?: number;
+    topK?: number;
+    topP?: number;
+    classifier_free_guidance?: number;
+}
+
+export interface CustomGenerateParams extends GenerateParams {
+    reference_audio?: string;
+    style?: string;
+    bpm?: number;
+    key?: string;
+    mode?: string;
+}
+
+export interface ExtendParams {
+    audio_id: string;
+    duration: number;
+}
+
+export interface GenerationResponse {
+    id: string;
+    status: 'pending' | 'processing' | 'completed' | 'failed';
+    audio_url?: string;
+    error?: string;
+}

package/src/types/index.ts

@@ -0,0 +1,34 @@
+export interface GenerateParams {
+    prompt: string;
+    duration?: number;
+    temperature?: number;
+    topK?: number;
+    topP?: number;
+    classifier_free_guidance?: number;
+}
+
+export interface CustomGenerateParams {
+    prompt: string;
+    duration?: number;
+    temperature?: number;
+    topK?: number;
+    topP?: number;
+    classifier_free_guidance?: number;
+    reference_audio?: string;
+    style?: string;
+    bpm?: number;
+    key?: string;
+    mode?: string;
+}
+
+export interface ExtendParams {
+    audio_id: string;
+    duration: number;
+}
+
+export interface GenerationResponse {
+    id: string;
+    status: string;
+    url?: string;
+    error?: string;
+}

package/tsconfig.json

@@ -0,0 +1,24 @@
+{
+    "compilerOptions": {
+        "outDir": "dist",
+        "rootDir": "src",
+        "lib": ["ESNext", "dom"],
+        "module": "Preserve",
+        "moduleResolution": "Bundler",
+        "strict": false,
+        "esModuleInterop": true,
+        "skipLibCheck": true,
+        "forceConsistentCasingInFileNames": false,
+        "allowImportingTsExtensions": true,
+        "declaration": true,
+        "emitDeclarationOnly": true,
+        "resolveJsonModule": true,
+        "noImplicitAny": false,
+        "allowJs": true,
+        "checkJs": false,
+        "noEmitOnError": false,
+        "moduleDetection": "force",
+        "allowArbitraryExtensions": true
+    },
+    "include": ["src/**/*.ts"]
+}

package/tsup.config.ts

@@ -0,0 +1,11 @@
+import { defineConfig } from "tsup";
+
+export default defineConfig({
+  entry: ["src/index.ts"],
+  format: ["cjs", "esm"],
+  dts: true,
+  splitting: false,
+  sourcemap: true,
+  clean: true,
+  external: ["@elizaos/core"]
+});

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2024 ElizaOS
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.