Switch text chat to Anthropic Messages API, improve agent ergonomics

- Use /anthropic/v1/messages endpoint with x-api-key auth for text chat
- Native thinking block support (dim + header styling in streaming)
- Bare --message strings default to user role (no "user:" prefix needed)
- Add speech voices command (list system voices, filter by --language)
- Default speech/music to URL output (--out opts into file save)
- Video generate waits by default, returns download URL (--no-wait for async)
- Warn on stderr when region detection fails both probes

Author: tars90percent

src/args.ts

@@ -47,7 +47,7 @@ export function parseArgs(argv: string[]): ParsedArgs {
 
       // Boolean flags
       if (['quiet', 'verbose', 'noColor', 'yes', 'dryRun', 'help', 'stream',
-           'subtitles', 'wait', 'noBrowser'].includes(camelKey)) {
+           'subtitles', 'wait', 'noWait', 'noBrowser'].includes(camelKey)) {
         (flags as Record<string, unknown>)[camelKey] = true;
         i++;
         continue;

src/client/endpoints.ts

@@ -1,11 +1,15 @@
 export function chatEndpoint(baseUrl: string): string {
-  return `${baseUrl}/v1/text/chatcompletion_v2`;
+  return `${baseUrl}/anthropic/v1/messages`;
 }
 
 export function speechEndpoint(baseUrl: string): string {
   return `${baseUrl}/v1/t2a_v2`;
 }
 
+export function voicesEndpoint(baseUrl: string): string {
+  return `${baseUrl}/v1/get_voice`;
+}
+
 export function imageEndpoint(baseUrl: string): string {
   return `${baseUrl}/v1/image_generation`;
 }

src/client/http.ts

@@ -13,6 +13,7 @@ export interface RequestOpts {
   timeout?: number;
   stream?: boolean;
   noAuth?: boolean;
+  authStyle?: 'bearer' | 'x-api-key';
 }
 
 export async function request(
@@ -27,11 +28,15 @@ export async function request(
 
   if (!opts.noAuth) {
     const credential = await resolveCredential(config);
-    headers['Authorization'] = `Bearer ${credential.token}`;
+    if (opts.authStyle === 'x-api-key') {
+      headers['x-api-key'] = credential.token;
+    } else {
+      headers['Authorization'] = `Bearer ${credential.token}`;
+    }
 
     if (config.verbose) {
       process.stderr.write(`> ${opts.method || 'GET'} ${opts.url}\n`);
-      process.stderr.write(`> Authorization: Bearer ${credential.token.slice(0, 8)}...\n`);
+      process.stderr.write(`> Auth: ${credential.token.slice(0, 8)}...\n`);
     }
   }
 

src/commands/music/generate.ts

@@ -21,13 +21,12 @@ export default defineCommand({
     { flag: '--sample-rate <hz>', description: 'Sample rate (default: 44100)' },
     { flag: '--bitrate <bps>', description: 'Bitrate (default: 256000)' },
     { flag: '--stream', description: 'Stream raw audio to stdout' },
-    { flag: '--out <path>', description: 'Output file path' },
-    { flag: '--out-format <fmt>', description: 'Output format: hex (default), url' },
+    { flag: '--out <path>', description: 'Save audio to file (uses hex decoding)' },
   ],
   examples: [
+    'minimax music generate --prompt "Upbeat pop" --lyrics "La la la..."',
     'minimax music generate --prompt "Indie folk, melancholic" --lyrics-file song.txt --out my_song.mp3',
     'minimax music generate --prompt "Upbeat pop" --lyrics "La la la..." --out summer.mp3',
-    'minimax music generate --prompt "Jazz lounge" --out-format url --output json',
   ],
   async run(config: Config, flags: GlobalFlags) {
     const prompt = flags.prompt as string | undefined;
@@ -52,7 +51,8 @@ export default defineCommand({
       process.stderr.write('Warning: No lyrics provided. Use --lyrics or --lyrics-file to include lyrics.\n');
     }
 
-    const outFormat = (flags.outFormat as string) || 'hex';
+    const outPath = flags.out as string | undefined;
+    const outFormat = outPath ? 'hex' : 'url';
     const format = detectOutputFormat(config.output);
 
     const body: MusicRequest = {
@@ -64,7 +64,7 @@ export default defineCommand({
         sample_rate: (flags.sampleRate as number) || 44100,
         bitrate: (flags.bitrate as number) || 256000,
       },
-      output_format: outFormat as 'url' | 'hex',
+      output_format: outFormat,
       stream: flags.stream === true,
     };
 
@@ -94,41 +94,28 @@ export default defineCommand({
       body,
     });
 
-    if (outFormat === 'url' && response.data.audio_url) {
+    if (outPath && response.data.audio) {
+      const audioBuffer = Buffer.from(response.data.audio, 'hex');
+      writeFileSync(outPath, audioBuffer);
+
       if (config.quiet) {
-        console.log(response.data.audio_url);
+        console.log(outPath);
       } else {
         console.log(formatOutput({
-          url: response.data.audio_url,
+          saved: outPath,
           duration_ms: response.extra_info?.audio_length,
           size_bytes: response.extra_info?.audio_size,
+          sample_rate: response.extra_info?.audio_sample_rate,
         }, format));
       }
-      return;
-    }
-
-    // Hex format — decode and write to file
-    const outPath = flags.out as string;
-    if (!outPath) {
-      throw new CLIError(
-        '--out is required when using hex output format.',
-        ExitCode.USAGE,
-        'minimax music generate --prompt <text> --out song.mp3',
-      );
-    }
-
-    if (response.data.audio) {
-      const audioBuffer = Buffer.from(response.data.audio, 'hex');
-      writeFileSync(outPath, audioBuffer);
-
+    } else if (response.data.audio_url) {
       if (config.quiet) {
-        console.log(outPath);
+        console.log(response.data.audio_url);
       } else {
         console.log(formatOutput({
-          saved: outPath,
+          url: response.data.audio_url,
           duration_ms: response.extra_info?.audio_length,
           size_bytes: response.extra_info?.audio_size,
-          sample_rate: response.extra_info?.audio_sample_rate,
         }, format));
       }
     }

src/commands/speech/synthesize.ts

@@ -12,7 +12,7 @@ import { readFileSync, writeFileSync } from 'fs';
 export default defineCommand({
   name: 'speech synthesize',
   description: 'Synchronous TTS, up to 10k chars (speech-2.8-hd / 2.6 / 02)',
-  usage: 'minimax speech synthesize --text <text> --out <path> [flags]',
+  usage: 'minimax speech synthesize --text <text> [--out <path>] [flags]',
   options: [
     { flag: '--model <model>', description: 'Model ID (default: speech-2.8-hd)' },
     { flag: '--text <text>', description: 'Text to synthesize' },
@@ -29,14 +29,13 @@ export default defineCommand({
     { flag: '--subtitles', description: 'Include subtitle timing data' },
     { flag: '--pronunciation <from/to>', description: 'Custom pronunciation (repeatable)' },
     { flag: '--sound-effect <effect>', description: 'Add sound effect' },
-    { flag: '--out <path>', description: 'Output file path' },
-    { flag: '--out-format <fmt>', description: 'Output format: hex (default), url' },
+    { flag: '--out <path>', description: 'Save audio to file (uses hex decoding)' },
     { flag: '--stream', description: 'Stream raw audio to stdout' },
   ],
   examples: [
+    'minimax speech synthesize --text "Hello, world!"',
     'minimax speech synthesize --text "Hello, world!" --out hello.mp3',
     'echo "Breaking news." | minimax speech synthesize --text-file - --out news.mp3',
-    'minimax speech synthesize --text "Link" --out-format url --output json',
     'minimax speech synthesize --text "Stream" --stream | mpv --no-terminal -',
   ],
   async run(config: Config, flags: GlobalFlags) {
@@ -59,7 +58,8 @@ export default defineCommand({
 
     const model = (flags.model as string) || 'speech-2.8-hd';
     const voice = (flags.voice as string) || 'English_expressive_narrator';
-    const outFormat = (flags.outFormat as string) || 'hex';
+    const outPath = flags.out as string | undefined;
+    const outFormat = outPath ? 'hex' : 'url';
     const format = detectOutputFormat(config.output);
 
     const body: SpeechRequest = {
@@ -77,7 +77,7 @@ export default defineCommand({
         bitrate: (flags.bitrate as number) || 128000,
         channel: (flags.channels as number) || 1,
       },
-      output_format: outFormat as 'url' | 'hex',
+      output_format: outFormat,
       stream: flags.stream === true,
     };
 
@@ -117,41 +117,30 @@ export default defineCommand({
       body,
     });
 
-    if (outFormat === 'url' && response.data.audio_url) {
+    if (outPath && response.data.audio) {
+      // --out given: decode hex and save to file
+      const audioBuffer = Buffer.from(response.data.audio, 'hex');
+      writeFileSync(outPath, audioBuffer);
+
       if (config.quiet) {
-        console.log(response.data.audio_url);
+        console.log(outPath);
       } else {
         console.log(formatOutput({
-          url: response.data.audio_url,
+          saved: outPath,
           duration_ms: response.extra_info?.audio_length,
           size_bytes: response.extra_info?.audio_size,
+          sample_rate: response.extra_info?.audio_sample_rate,
         }, format));
       }
-      return;
-    }
-
-    // Hex format — decode and write to file
-    const outPath = flags.out as string;
-    if (!outPath && !config.quiet) {
-      throw new CLIError(
-        '--out is required when using hex output format.',
-        ExitCode.USAGE,
-        'minimax speech synthesize --text "Hello" --out hello.mp3',
-      );
-    }
-
-    if (response.data.audio && outPath) {
-      const audioBuffer = Buffer.from(response.data.audio, 'hex');
-      writeFileSync(outPath, audioBuffer);
-
+    } else if (response.data.audio_url) {
+      // No --out: return URL
       if (config.quiet) {
-        console.log(outPath);
+        console.log(response.data.audio_url);
       } else {
         console.log(formatOutput({
-          saved: outPath,
+          url: response.data.audio_url,
           duration_ms: response.extra_info?.audio_length,
           size_bytes: response.extra_info?.audio_size,
-          sample_rate: response.extra_info?.audio_sample_rate,
         }, format));
       }
     }

src/commands/speech/voices.ts

@@ -0,0 +1,76 @@
+import { defineCommand } from '../../command';
+import { requestJson } from '../../client/http';
+import { voicesEndpoint } from '../../client/endpoints';
+import { formatOutput, detectOutputFormat } from '../../output/formatter';
+import type { Config } from '../../config/schema';
+import type { GlobalFlags } from '../../types/flags';
+import type { VoiceListResponse, SystemVoiceInfo } from '../../types/api';
+
+function extractLanguage(voiceId: string): string {
+  // voice_id format: "Language_VoiceName" or "Language (Dialect)_VoiceName"
+  // Match up to the last underscore-separated word that starts with uppercase
+  const match = voiceId.match(/^(.+?)_[A-Z]/);
+  return match ? match[1] : voiceId;
+}
+
+function filterByLanguage(voices: SystemVoiceInfo[], language: string): SystemVoiceInfo[] {
+  const lang = language.toLowerCase();
+  return voices.filter(v => extractLanguage(v.voice_id).toLowerCase().includes(lang));
+}
+
+export default defineCommand({
+  name: 'speech voices',
+  description: 'List available system voices',
+  usage: 'minimax speech voices [--language <lang>]',
+  options: [
+    { flag: '--language <lang>', description: 'Filter voices by language (e.g. english, korean, japanese)' },
+  ],
+  examples: [
+    'minimax speech voices',
+    'minimax speech voices --language english',
+    'minimax speech voices --language korean',
+    'minimax speech voices --output json',
+  ],
+  async run(config: Config, flags: GlobalFlags) {
+    const format = detectOutputFormat(config.output);
+
+    if (config.dryRun) {
+      console.log(formatOutput({ request: { voice_type: 'system' } }, format));
+      return;
+    }
+
+    const response = await requestJson<VoiceListResponse>(config, {
+      url: voicesEndpoint(config.baseUrl),
+      method: 'POST',
+      body: { voice_type: 'system' },
+    });
+
+    const voices = response.system_voice ?? [];
+    const language = flags.language as string | undefined;
+
+    if (language) {
+      const filtered = filterByLanguage(voices, language);
+
+      if (format !== 'text') {
+        console.log(formatOutput(filtered, format));
+        return;
+      }
+
+      for (const v of filtered) {
+        const desc = v.description?.join('; ') || '';
+        const name = v.voice_name ? ` (${v.voice_name})` : '';
+        console.log(`  ${v.voice_id}${name}`);
+        if (desc) console.log(`    ${desc}`);
+      }
+    } else {
+      if (format !== 'text') {
+        console.log(formatOutput(voices.map(v => v.voice_id), format));
+        return;
+      }
+
+      for (const v of voices) {
+        console.log(v.voice_id);
+      }
+    }
+  },
+});