@j-o-r/hello-dave 0.0.9 → 0.1.0

package/lib/genericToolset.js

@@ -7,12 +7,15 @@ import { fileURLToPath } from 'node:url';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
-// STANDARDIZED UTILS PATHS (hoisted constants for performance/consistency)
+// STANDARDIZED UTILS PATHS
 const utilsDir = path.resolve(__dirname, '..', 'utils');
 const searchSessionsSh = path.join(utilsDir, 'search_sessions.sh');
 const listSessionsSh = path.join(utilsDir, 'list_sessions.sh');
 const syntaxCheckSh = path.join(utilsDir, 'syntax_check.sh');
 
+// Do we have a SSH access point?
+const SSH_EP = process.env.SSH_EP || '';
+
 const user = await env();
 const environment = `
 Name: ${user.name}
@@ -26,47 +29,7 @@ ExternalIp: ${user.external_ip}
 const tools = new ToolSet('auto');
 
 /**
- * Reduces verbose JavaScript evaluation error output to essential info (line number + core message).
- * @param {string} errorStr - Full Node.js error string.
- * @returns {string} Simplified error.
- * @private
- */
-const getJSError = (errorStr) => {
-	let result = '';
-	const linematch = errorStr.match(/\[eval\]:(\d+)/);
-	const lineNumber = linematch ? linematch[1] : '';
-	const match = errorStr.split(/\" \"\[eval\]:\d+/s);
-	if (match.length > 1) {
-		const res = match[1].split('\n').slice(0, -10).join('\n');
-		result = `Error: line ${lineNumber}\n${res} `;
-	} else {
-		result = errorStr;
-	}
-	return result;
-};
-// /**
-// * Try to prevent double escaping by LLMS models
-// * When a string stays a string it is probably double escaped
-// * @parameter {string} s
-// * @returns {string}
-// */
-// const guessOverEscaping = (s) => {
-// 	let test;
-// 	if (typeof s === 'string') {
-// 		try {
-// 			test = JSON.parse(s);
-// 		} catch (_e) { }
-// 		if (typeof test === 'string') {
-// 			return test;
-// 		}
-// 	}
-// 	return s;
-// }
-
-/**
- * Try to prevent double escaping by LLMs.
- * Handles common patterns like \"path\", \\\"path\\\", JSON strings,
- * and multiple layers while being much safer on complex bash/JS scripts.
+ * Single source of truth for cleaning over-escaped strings from LLMs.
  */
 const guessOverEscaping = (s) => {
 	if (typeof s !== 'string') return s;
@@ -74,13 +37,12 @@ const guessOverEscaping = (s) => {
 	let current = s.trim();
 	const seen = new Set();
 	let iterations = 0;
-	const MAX_ITER = 6; // safety limit
+	const MAX_ITER = 6;
 
 	while (iterations < MAX_ITER && !seen.has(current)) {
 		seen.add(current);
 		iterations++;
 
-		// 1. Most reliable: JSON.parse (undoes proper JSON string escaping)
 		try {
 			const parsed = JSON.parse(current);
 			if (typeof parsed === 'string') {
@@ -89,24 +51,19 @@ const guessOverEscaping = (s) => {
 			}
 		} catch (e) { }
 
-		// 2. Specifically strip the pattern you saw: \"...\"  (including the backslashes)
 		if (current.startsWith('\\"') && current.endsWith('\\"')) {
 			current = current.slice(2, -2);
 			continue;
 		}
 
-		// 3. Strip normal outer quotes, but protect JSON objects/arrays
 		if (current.startsWith('"') && current.endsWith('"') && current.length > 2) {
-			const inner = current.slice(1, -1);
-			const trimmedInner = inner.trim();
-			if (!trimmedInner.startsWith('{') && !trimmedInner.startsWith('[')) {
+			const inner = current.slice(1, -1).trim();
+			if (!inner.startsWith('{') && !inner.startsWith('[')) {
 				current = inner;
 				continue;
 			}
 		}
 
-		// 4. Conservative global unescape of \" → "
-		//    Only applied to short strings without newlines (i.e. not full scripts)
 		if (!current.includes('\n') && (current.match(/\\"/g) || []).length >= 1) {
 			const lessEscaped = current.replace(/\\"/g, '"');
 			if (lessEscaped !== current) {
@@ -115,20 +72,31 @@ const guessOverEscaping = (s) => {
 			}
 		}
 
-		break; // no more productive changes
+		break;
 	}
 
 	return current;
-};/**
+};
+
+const getJSError = (errorStr) => {
+	let result = '';
+	const linematch = errorStr.match(/\[eval\]:(\d+)/);
+	const lineNumber = linematch ? linematch[1] : '';
+	const match = errorStr.split(/" "\[eval\]:\d+/s);
+	if (match.length > 1) {
+		const res = match[1].split('\n').slice(0, -10).join('\n');
+		result = `Error: line ${lineNumber}\n${res} `;
+	} else {
+		result = errorStr;
+	}
+	return result;
+};
+
+/**
  * @module lib/genericToolset
- * Secure utility tools for code execution, file I/O, system ops. Pre-populated ToolSet.
- * 
- * @example
- * import tools from './lib/genericToolset.js';
- * await tools.call('get_user_env', {});
- * 
- * @see {@link module:./index~ToolSet}
+ * Secure utility tools. 
  */
+
 tools.add(
 	'javascript_interpreter',
 	'Execute ESM ES6 JavaScript on node.',
@@ -167,54 +135,45 @@ tools.add(
 
 tools.add(
 	'execute_bash_script',
-	'Execute raw bash script or command (no escaping needed). Supports timeout to prevent hangs.',
+	'Execute raw bash script or command (no escaping needed). Supports timeout.',
 	{
 		type: 'object',
 		properties: {
 			bash_script: {
 				type: 'string',
-				description: `Raw bash verbatim. Supports all syntax safely via stdin. System: ${user.system}`
+				description: `Write raw bash exactly...`
 			},
-			timeout: {
-				type: 'number',
-				default: 360,
-				description: 'Max execution time in seconds (default 360 seconds, 0 is no timeout). Uses @j-o-r/sh timeout (ms) with SIGTERM on expiry to prevent hangs from interactive prompts or slow commands.'
-			}
+			timeout: { type: 'number', default: 360 },
+			strict: { type: 'boolean', default: false }
 		},
 		required: ['bash_script']
 	},
 	async (params) => {
-		const timeoutSec = Number(params.timeout ?? 300);
-		const bash_script = guessOverEscaping(params.bash_script);
+		let bash_script = params.bash_script;
+		if (typeof bash_script !== 'string') bash_script = '';
+		// Check if the bash_script string has a shebang on the first line '#!'
+		// If not, add a bash shebang
+		const firstLine = bash_script.split('\n')[0] || '';
+		if (!firstLine.trim().startsWith('#!')) {
+			bash_script = '#!/bin/bash\n' + bash_script;
+		}
+		const timeoutSec = Number(params.timeout ?? 360);
+		const prams = params.strict ? '' : '-S error';
 		if (isNaN(timeoutSec) || timeoutSec < 0) throw new Error('Invalid timeout');
 		const timeout = timeoutSec * 1000;
-		// return await SH`bash`.options({ timeout: timeoutMs }).run(params.bash_script);
-		const delim = `END_SCRIPT_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
-		return await SH`bash <<'${delim}'
-${bash_script}
-${delim}
-`.options({ timeout }).run();
-
+		const valid = SH`shellcheck ${prams} -`.runSync(bash_script).stdout.toString().trim();
+		if (valid !== '') throw new Error(valid);
+		return await SH`bash`.options({ timeout }).run(bash_script);
 	}
 );
 
 tools.add(
-	'send_email',
-	'Send email via msmtp.',
-	{
-		type: 'object',
-		properties: {
-			to: { type: 'string', description: 'Recipient' },
-			subject: { type: 'string', description: 'Subject' },
-			body: { type: 'string', description: 'Body' }
-		},
-		required: ['to', 'subject', 'body']
-	},
+	'send_email', 'Send email via msmtp.', { type: 'object', properties: { to: { type: 'string' }, subject: { type: 'string' }, body: { type: 'string' } }, required: ['to', 'subject', 'body'] },
 	async (params) => {
 		const to = guessOverEscaping(params.to);
 		const subject = guessOverEscaping(params.subject);
 		const body = guessOverEscaping(params.body);
-		const delim = `END_EMAIL_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+		const delim = `END_EMAIL_${Date.now().toString(36)}`;
 		return await SH`msmtp ${params.to} <<'${delim}'
 To: ${to}
 Subject: ${subject}
@@ -226,174 +185,80 @@ ${delim}
 );
 
 tools.add(
-	'open_link',
-	'Open URL/file with xdg-open.',
-	{
-		type: 'object',
-		properties: {
-			url: { type: 'string', description: 'URL or file path' }
-		},
-		required: ['url']
-	},
-	async (params) => {
-		let url = guessOverEscaping(params.url?.trim());
-		return await SH`xdg-open ${[url]}`.run();
-	}
+	'open_link', 'Open URL/file with xdg-open.', { type: 'object', properties: { url: { type: 'string' } }, required: ['url'] },
+	async (params) => await SH`xdg-open ${[guessOverEscaping(params.url)]}`.run()
 );
 
 tools.add(
-	'execute_remote_script',
-	'Run bash on remote via SSH. Supports timeout to prevent hangs.',
+	'execute_remote_script', `Run bash on remote via SSH. ${SSH_EP}`,
 	{
 		type: 'object',
 		properties: {
-			url: { type: 'string', description: 'ssh://user@host[:port]' },
-			script: { type: 'string', description: 'Raw script' },
-			timeout: {
-				type: 'number',
-				default: 30,
-				description: 'Max execution time in seconds (default 30). Uses @j-o-r/sh timeout (ms) with SIGTERM on SSH process expiry.'
-			}
+			url: { type: 'string', description: `ssh://user@host[:port] default: ${SSH_EP}` },
+			script: { type: 'string' },
+			timeout: { type: 'number', default: 30 }
 		},
 		required: ['url', 'script']
 	},
 	async (params) => {
 		let { url, script } = params;
+		if (!url || url === '') url = SSH_EP;
 		url = guessOverEscaping(url);
 		script = guessOverEscaping(script);
-
-		const timeoutSec = Number(params.timeout ?? 30);
-		if (isNaN(timeoutSec) || timeoutSec <= 0) throw new Error('Invalid timeout');
-		const timeoutMs = timeoutSec * 1000;
+		const timeoutMs = (Number(params.timeout ?? 30)) * 1000;
 		if (!url.startsWith('ssh://')) throw new Error('ssh://user@host[:port]');
 		const withoutProto = url.slice(6);
 		const parts = withoutProto.split(':');
 		let port = 22, userHost = withoutProto;
 		if (parts.length > 1) { userHost = parts[0]; port = parseInt(parts[1]); }
 		const [user, host] = userHost.split('@');
-		if (!user || !host) throw new Error('Invalid SSH URL');
 		return await SH`ssh -p ${port} ${user}@${host} bash`.options({ timeout: timeoutMs }).run(script);
 	}
 );
 
 tools.add(
-	'history_search',
-	'Search/list chat sessions in .cache/.',
-	{
-		type: 'object',
-		properties: {
-			query: { type: 'string', description: 'Query/regex or empty to list' }
-		},
-		required: []
-	},
+	'history_search', 'Search/list chat sessions in .cache/.',
+	{ type: 'object', properties: { query: { type: 'string' } } },
 	async (params) => {
 		if (typeof params.query === 'string' && params.query.trim()) {
-			const q = guessOverEscaping(params.query);
-			return await SH`${searchSessionsSh} "${bashEscape(q)}"`.run();
+			return await SH`${searchSessionsSh} "${bashEscape(guessOverEscaping(params.query))}"`.run();
 		}
 		return await SH`${listSessionsSh}`.run();
 	}
 );
 
 tools.add(
-	'read_file',
-	'Read file from CWD (relative path only).',
-	{
-		type: 'object',
-		properties: {
-			file: { type: 'string', description: `Relative path. cwd: ${user.cwd}` }
-		},
-		required: ['file']
-	},
+	'read_file', 'Read file from CWD (relative path only).',
+	{ type: 'object', properties: { file: { type: 'string' } }, required: ['file'] },
 	async (params) => {
 		let file = guessOverEscaping(params.file?.trim());
-		if (typeof file !== 'string' || !file || file.startsWith('/') || file.includes('..') || file.includes('\\\\')) {
-			throw new Error('Relative CWD path only (no /, .., \\\\).');
-		}
-		const resolved = path.resolve(process.cwd(), file);
-		if (!resolved.startsWith(process.cwd())) throw new Error('Escapes CWD.');
-		return await fs.readFile(resolved, 'utf8');
+		if (!file || file.startsWith('/') || file.includes('..')) throw new Error('Relative CWD path only');
+		return await fs.readFile(path.resolve(process.cwd(), file), 'utf8');
 	}
 );
 
 tools.add(
-	'write_file',
-	'Write/validate file in CWD. Auto-syntax check + JS fix + chmod.',
-	{
-		type: 'object',
-		properties: {
-			file: { type: 'string', description: `Relative path. cwd: ${user.cwd}` },
-			content: { type: 'string', description: 'Raw content verbatim (no escaping).' }
-		},
-		required: ['file', 'content']
-	},
+	'write_file', 'Write/validate file in CWD.',
+	{ type: 'object', properties: { file: { type: 'string' }, content: { type: 'string' } }, required: ['file', 'content'] },
 	async (params) => {
-		let file = guessOverEscaping(params.file?.trim());
-		let content = guessOverEscaping(params.content ?? '');
-		if (typeof file !== 'string' || !file || file.startsWith('/') || file.includes('..') || file.includes('\\\\')) {
-			throw new Error('Relative CWD path only.');
-		}
-		const resolved = path.resolve(process.cwd(), file);
-		if (!resolved.startsWith(process.cwd())) throw new Error('Escapes CWD.');
-		const dir = path.dirname(resolved);
-		const ext = path.extname(file);
-		let finalContent = content, validationMsg = '';
-
-		const temp1 = path.join(dir, `temp_${Date.now()}_${Math.random().toString(36).slice(2, 6)}${ext || '.tmp'}`);
-		await fs.writeFile(temp1, content, 'utf8');
-
-		try {
-			await SH`${syntaxCheckSh} ${[temp1]}`.run();
-			validationMsg = ' ✓ Syntax OK';
-		} catch (e) {
-			if (!['.js', '.mjs'].includes(ext)) {
-				await fs.unlink(temp1).catch(() => { });
-				throw new Error(`Syntax error: ${e.message}`);
-			}
-			let fixed = content.replace(/\\\\`/g, '\\`').replace(/\\\`/g, '`').replace(/\\`/g, '`').replace(/\\\$/g, '$').replace(/\\\${/g, '${');
-			const temp2 = path.join(dir, `temp_fix_${Date.now()}_${Math.random().toString(36).slice(2, 6)}.js`);
-			await fs.writeFile(temp2, fixed, 'utf8');
-			try {
-				await SH`${syntaxCheckSh} ${[temp2]}`.run();
-				finalContent = fixed;
-				await fs.rename(temp2, resolved);
-				await fs.unlink(temp1).catch(() => { });
-				validationMsg = ' ✓ Fixed JS';
-			} catch {
-				await fs.unlink(temp1).catch(() => { });
-				await fs.unlink(temp2).catch(() => { });
-				throw new Error(`Syntax error (fix failed): ${e.message}`);
-			}
-		}
-
-		if (validationMsg === ' ✓ Syntax OK') await fs.rename(temp1, resolved);
-
-		if (finalContent.startsWith('#!')) {
-			await SH`chmod +x ${[resolved]}`.run();
-			validationMsg += ' ✓ +x';
-		}
-
-		return `Wrote ${file} (${Buffer.byteLength(finalContent, 'utf8')} bytes).${validationMsg}`;
+		let fileParam = guessOverEscaping(params.file?.trim());
+		let content = guessOverEscaping(params.content || '');
+		if (!fileParam || fileParam.startsWith('/') || fileParam.includes('..')) throw new Error('Relative CWD path only');
+		const resolved = path.resolve(process.cwd(), fileParam);
+		await fs.mkdir(path.dirname(resolved), { recursive: true });
+		await fs.writeFile(resolved, content, 'utf8');
+		return `Wrote ${fileParam} (${Buffer.byteLength(content, 'utf8')} bytes).`;
 	}
 );
 
 tools.add(
-	'syntax_check',
-	'Syntax validate file via utils/syntax_check.sh.',
-	{
-		type: 'object',
-		properties: {
-			file: { type: 'string', description: 'Relative CWD path' }
-		},
-		required: ['file']
-	},
+	'syntax_check', 'Syntax validate file via utils/syntax_check.sh.',
+	{ type: 'object', properties: { file: { type: 'string' } }, required: ['file'] },
 	async (params) => {
 		const file = guessOverEscaping(params.file?.trim());
-		if (typeof file !== 'string' || !file) throw new Error('Relative path required.');
 		const resolved = path.resolve(process.cwd(), file);
-		if (!resolved.startsWith(process.cwd())) throw new Error('Escapes CWD.');
-		return await SH`${syntaxCheckSh} ${[resolved]}`.run();
+		return await SH`${syntaxCheckSh} ${resolved}`.run() || 'Syntax OK';
 	}
 );
 
-export default tools;
+export default tools;

package/lib/index.js

@@ -2,7 +2,9 @@ import {request as gpt} from './API/openai.com/reponses/text.js';
 import {request as xai} from './API/x.ai/responses.js';
 import {request as claude} from './API/anthropic.com/text.js';
 import {request as brave} from './API/brave.com/search.js';
-
+import minimax from './API/minimax/index.js';
+import stability from './API/stability.ai/index.js';
+import xai from './API/x.ai/index.js';
 import { env, GLOBAL } from './fafs.js';
 import ToolSet from './ToolSet.js';
 import AgentServer from './AgentServer.js';
@@ -23,6 +25,9 @@ const API = {
   search: {
   	brave
   },
+  minimax,
+  stability,
+  xai
 }
 export {
 	AgentManager,
@@ -38,3 +43,6 @@ export {
   wsCli,
   wsIO
 };
+
+// Export the dedicated CDN toolset
+export { default as CdnToolset } from './CdnToolset.js';

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@j-o-r/hello-dave",
   "type": "module",
-  "version": "0.0.9",
-  "description": "ESM toolkit for building AI agents with unified access to Grok (XAI), OpenAI, and Anthropic endpoints",
+  "version": "0.1.0",
+  "description": "ESM toolkit for building AI agents, CLI xai coding agent and unified access to Grok (XAI), OpenAI, and Anthropic endpoints, music, image and video creation toolsets from minimax, stability and x.ai.",
   "main": "./lib/index.js",
   "types": "./types/index.d.ts",
   "typesVersions": {

package/types/API/minimax/ImageToolset.d.ts

@@ -0,0 +1,3 @@
+export default tools;
+declare const tools: ToolSet;
+import ToolSet from '../../ToolSet.js';

package/types/API/minimax/MusicToolset.d.ts

@@ -0,0 +1,3 @@
+export default tools;
+declare const tools: ToolSet;
+import ToolSet from '../../ToolSet.js';

package/types/API/minimax/VideoToolset.d.ts

@@ -0,0 +1,3 @@
+export default tools;
+declare const tools: ToolSet;
+import ToolSet from '../../ToolSet.js';

package/types/API/minimax/image.d.ts

@@ -0,0 +1,109 @@
+/**
+ * Get authentication headers for Minimax API.
+ *
+ * @returns {Object} Headers object with Authorization Bearer token.
+ * @throws {Error} If MINIMAX_API_KEY environment variable is not set.
+ */
+export function getHeaders(): Object;
+/**
+ * Saves image data (either URL or base64) to a local temporary file.
+ * Handles both `response_format: 'url'` and `response_format: 'base64'`.
+ * Supports data URL prefix for base64.
+ *
+ * @param {string} imageData - Either a URL or a base64-encoded string (with or without data: prefix).
+ * @param {string} [filenamePrefix='minimax-image'] - Prefix for the local filename.
+ * @param {number} [index=0] - Index for multiple images to avoid filename collisions.
+ * @returns {Promise<string>} Absolute path to the saved local file.
+ */
+export function saveImageToLocal(imageData: string, filenamePrefix?: string, index?: number): Promise<string>;
+/**
+ * Core image generation request (supports both Text-to-Image and Image-to-Image).
+ *
+ * Fully implements the official Minimax Image Generation API
+ * as documented in `lib/API/minimax/image.generation.md` and `image.to.image.md`.
+ *
+ * Uses the single endpoint `/v1/image_generation`.
+ *
+ * Supports all models, parameters, and response formats.
+ *
+ * @param {string} prompt - Text description of the image, max 1500 characters.
+ * @param {Object} [options] - All available options from the official spec.
+ *
+ * @param {string} [options.model='image-01'] - Model to use.
+ *   Supported values:
+ *   - 'image-01' (default, text-to-image and img2img)
+ *   - 'image-01-live' (for image-to-image)
+ *
+ * @param {string} [options.aspect_ratio='1:1'] - Image aspect ratio.
+ *   Options: '1:1', '16:9', '4:3', '3:2', '2:3', '3:4', '9:16', '21:9'
+ *
+ * @param {number} [options.width] - Image width in px (512-2048, divisible by 8).
+ *   Only effective for model 'image-01'. aspect_ratio takes priority if both provided.
+ *
+ * @param {number} [options.height] - Image height in px (same rules as width).
+ *
+ * @param {string} [options.response_format='url'] - 'url' or 'base64'.
+ *   Default is `'url'` (user preference).
+ *   ⚠️ `url` links expire after 24 hours.
+ *
+ * @param {number} [options.seed] - Random seed for reproducibility.
+ *
+ * @param {number} [options.n=1] - Number of images to generate (1-9).
+ *
+ * @param {boolean} [options.prompt_optimizer=false] - Enable automatic prompt optimization.
+ *
+ * @param {Array<Object>} [options.subject_reference] - For Image-to-Image.
+ *   Array of subject references. Currently supports:
+ *   - { type: 'character', image_file: 'https://...' or 'data:image/...;base64,...' }
+ *
+ * @param {Object} [options.extra] - Any additional parameters not yet documented.
+ *
+ * @returns {Promise<{
+ *   image_urls: string[],        // Array from data.image_urls (if url format)
+ *   image_base64: string[],      // Array from data.image_base64 (if base64 format)
+ *   local_paths: string[],       // Absolute paths to saved files
+ *   metadata: Object,            // { success_count, failed_count }
+ *   id: string,                  // Trace ID
+ *   duration: number,            // API call duration in milliseconds
+ *   raw: object                  // Full raw response
+ * }>}
+ *
+ * @example
+ * // Text-to-Image (basic)
+ * const result = await requestImage("A serene mountain landscape at sunset", {
+ *   model: "image-01",
+ *   aspect_ratio: "16:9",
+ *   n: 2
+ * });
+ *
+ * @example
+ * // Image-to-Image
+ * const result = await requestImage("A girl looking into the distance", {
+ *   model: "image-01",
+ *   subject_reference: [{
+ *     type: "character",
+ *     image_file: "https://example.com/portrait.jpg"
+ *   }],
+ *   n: 1
+ * });
+ */
+export function requestImage(prompt: string, options?: {
+    model?: string | undefined;
+    aspect_ratio?: string | undefined;
+    width?: number | undefined;
+    height?: number | undefined;
+    response_format?: string | undefined;
+    seed?: number | undefined;
+    n?: number | undefined;
+    prompt_optimizer?: boolean | undefined;
+    subject_reference?: Object[] | undefined;
+    extra?: Object | undefined;
+}): Promise<{
+    image_urls: string[];
+    image_base64: string[];
+    local_paths: string[];
+    metadata: Object;
+    id: string;
+    duration: number;
+    raw: object;
+}>;

package/types/API/minimax/index.d.ts

@@ -0,0 +1,15 @@
+declare namespace _default {
+    export { music };
+    export { musicToolset };
+    export { video };
+    export { videoToolset };
+    export { image };
+    export { imageToolset };
+}
+export default _default;
+import * as music from './music.js';
+import musicToolset from './MusicToolset.js';
+import * as video from './video.js';
+import videoToolset from './VideoToolset.js';
+import * as image from './image.js';
+import imageToolset from './ImageToolset.js';

package/types/API/minimax/music.d.ts

@@ -0,0 +1,46 @@
+export function getHeaders(): {
+    'Content-Type': string;
+    Authorization: string;
+};
+export function saveAudioToLocal(audioData: any, filenamePrefix?: string): Promise<any>;
+export function createMusic(prompt: any, options?: {}): Promise<{
+    audio_url: any;
+    local_path: any;
+    duration: number;
+    raw: any;
+}>;
+export function changeMusic(prompt: any, options?: {}): Promise<{
+    audio_url: any;
+    local_path: any;
+    duration: number;
+    raw: any;
+}>;
+export function analyzeMusic(audioUrl: any, options?: {}): Promise<{
+    cover_feature_id: any;
+    formatted_lyrics: any;
+    structure_result: any;
+    audio_duration: any;
+    trace_id: any;
+    raw: any;
+}>;
+/**
+ * Generate complete song lyrics or edit/continue existing lyrics.
+ *
+ * @param {string} prompt - Theme, style, or editing instruction.
+ * @param {Object} [options]
+ * @param {'write_full_song'|'edit'} [options.mode='write_full_song']
+ * @param {string} [options.lyrics] - Existing lyrics (required for edit mode)
+ * @param {string} [options.title]
+ *
+ * @returns {Promise<{song_title: string, style_tags: string, lyrics: string, raw: object}>}
+ */
+export function generateLyrics(prompt: string, options?: {
+    mode?: "write_full_song" | "edit" | undefined;
+    lyrics?: string | undefined;
+    title?: string | undefined;
+}): Promise<{
+    song_title: string;
+    style_tags: string;
+    lyrics: string;
+    raw: object;
+}>;