Communitygithub.com

ARYAN2302/liquid_researcher

Implémentez des capacités de synthèse vocale (TTS) à l'aide du SDK z-ai-web-dev-sdk. Utilisez cette compétence lorsque l'utilisateur a besoin de convertir du texte en parole naturelle, de créer du contenu audio, de construire des applications vocales ou de générer des fichiers audio parlés. Prend en charge plusieurs voix, une vitesse réglable et divers formats audio.

Qu'est-ce que liquid_researcher ?

Cette compétence guide l'implémentation de la fonctionnalité de synthèse vocale (TTS) à l'aide du package z-ai-web-dev-sdk, permettant de convertir du texte en audio parlé de manière naturelle. Elle prend en charge de multiples voix (tongtong, chuichui, xiaochen, jam, kazi, douji, luodo), une vitesse réglable (0.5 à 2.0), un volume ajustable (jusqu'à 10), et plusieurs formats de sortie audio (WAV, MP3, PCM). Le SDK doit être utilisé exclusivement en backend ; l'utilisation côté client est interdite. La compétence détaille les contraintes de l'API, notamment une limite de 1024 caractères par requête, et propose des bonnes pratiques pour gérer les textes longs (découpage en morceaux), la réutilisation d'instance SDK, et la gestion d'erreurs. Des exemples complets sont fournis pour une utilisation en ligne de commande (CLI), en programmation (JavaScript/TypeScript), dans des frameworks web (Next.js, Express), ainsi que pour le traitement par lots et la génération dynamique de contenu.

Compatible avec~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/ARYAN2302/liquid_researcher/tree/HEAD/skills/TTS

Demander à votre IA préférée

Ouvre une nouvelle conversation avec cette compétence d'agent déjà préchargée.

Documentation

Compétence TTS (Synthèse Vocale)

Cette compétence guide l'implémentation de la fonctionnalité de synthèse vocale (TTS) à l'aide du package z-ai-web-dev-sdk, permettant de convertir du texte en audio parlé de manière naturelle.

Chemin de la Compétence

Emplacement de la Compétence : {chemin_du_projet}/skills/TTS

Cette compétence se trouve au chemin ci-dessus dans votre projet.

Scripts de Référence : Des exemples de scripts de test sont disponibles dans le répertoire {Emplacement_Compétence}/scripts/ pour des tests et une référence rapides. Voir {Emplacement_Compétence}/scripts/tts.ts pour un exemple fonctionnel.

Aperçu

La synthèse vocale vous permet de créer des applications qui génèrent de l'audio parlé à partir d'un texte saisi, en prenant en charge diverses voix, vitesses et formats de sortie pour divers cas d'utilisation.

IMPORTANT : z-ai-web-dev-sdk DOIT être utilisé uniquement dans le code backend. Ne l'utilisez jamais dans le code côté client.

Limites et Contraintes de l'API

Avant d'implémenter la fonctionnalité TTS, soyez conscient de ces limitations importantes :

Contraintes du Texte d'Entrée

  • Longueur maximale : 1024 caractères par requête
  • Un texte dépassant cette limite doit être divisé en morceaux plus petits

Paramètres Audio

  • Plage de vitesse : 0,5 à 2,0
    • 0,5 = moitié vitesse (plus lent)
    • 1,0 = vitesse normale (par défaut)
    • 2,0 = double vitesse (plus rapide)
  • Plage de volume : Supérieur à 0, jusqu'à 10
    • Par défaut : 1,0
    • Les valeurs doivent être supérieures à 0 (exclusif) et jusqu'à 10 (inclus)

Format et Streaming

  • Limitation du streaming : Lorsque stream: true est activé, seul le format pcm est pris en charge
  • Non-streaming : Prend en charge les formats wav, pcm et mp3
  • Fréquence d'échantillonnage : 24000 Hz (recommandé)

Bonne Pratique pour le Texte Long

function splitTextIntoChunks(text, maxLength = 1000) {
  const chunks = [];
  const sentences = text.match(/[^.!?]+[.!?]+/g) || [text];
  
  let currentChunk = '';
  for (const sentence of sentences) {
    if ((currentChunk + sentence).length <= maxLength) {
      currentChunk += sentence;
    } else {
      if (currentChunk) chunks.push(currentChunk.trim());
      currentChunk = sentence;
    }
  }
  if (currentChunk) chunks.push(currentChunk.trim());
  
  return chunks;
}

Prérequis

Le package z-ai-web-dev-sdk est déjà installé. Importez-le comme indiqué dans les exemples ci-dessous.

Utilisation en Ligne de Commande (CLI) (Pour les Tâches Simples)

Pour les conversions texte-parole simples, vous pouvez utiliser la CLI z-ai au lieu d'écrire du code. C'est idéal pour la génération audio rapide, le test des voix ou l'automatisation simple.

TTS de Base

# Convertir le texte en parole (format WAV par défaut)
z-ai tts --input "Bonjour le monde" --output ./bonjour.wav

# Utilisation des options courtes
z-ai tts -i "Bonjour le monde" -o ./bonjour.wav

Différentes Voix et Vitesse

# Utiliser une voix spécifique
z-ai tts -i "Bienvenue sur notre service" -o ./bienvenue.wav --voice tongtong

# Ajuster la vitesse de la parole (0,5-2,0)
z-ai tts -i "Ceci est une parole plus rapide" -o ./rapide.wav --speed 1.5

# Parole plus lente
z-ai tts -i "Ceci est une parole plus lente" -o ./lent.wav --speed 0.8

Différents Formats de Sortie

# Format MP3
z-ai tts -i "Bonjour le monde" -o ./bonjour.mp3 --format mp3

# Format WAV (par défaut)
z-ai tts -i "Bonjour le monde" -o ./bonjour.wav --format wav

# Format PCM
z-ai tts -i "Bonjour le monde" -o ./bonjour.pcm --format pcm

Sortie en Streaming

# Génération audio en streaming
z-ai tts -i "Ceci est un texte plus long qui sera diffusé en continu" -o ./stream.wav --stream

Paramètres CLI

  • --input, -i <texte> : Requis - Texte à convertir en parole (max 1024 caractères)
  • --output, -o <chemin> : Requis - Chemin du fichier audio de sortie
  • --voice, -v <voix> : Optionnel - Type de voix (par défaut : tongtong)
  • --speed, -s <nombre> : Optionnel - Vitesse de la parole, 0,5-2,0 (par défaut : 1,0)
  • --format, -f <format> : Optionnel - Format de sortie : wav, mp3, pcm (par défaut : wav)
  • --stream : Optionnel - Activer la sortie en streaming (ne prend en charge que le format pcm)

Quand Utiliser la CLI vs le SDK

Utiliser la CLI pour :

  • Conversions rapides de texte en parole
  • Tester différentes voix et vitesses
  • Génération audio par lots simple
  • Scripts d'automatisation en ligne de commande

Utiliser le SDK pour :

  • Génération audio dynamique dans les applications
  • Intégration avec des services web
  • Pipelines de traitement audio personnalisés
  • Applications de production avec des exigences complexes

Implémentation de Base du TTS

Texte Simple en Parole

import ZAI from 'z-ai-web-dev-sdk';
import fs from 'fs';

async function textToSpeech(text, outputPath) {
  const zai = await ZAI.create();

  const response = await zai.audio.tts.create({
    input: text,
    voice: 'tongtong',
    speed: 1.0,
    response_format: 'wav',
    stream: false
  });

  // Get array buffer from Response object
  const arrayBuffer = await response.arrayBuffer();
  const buffer = Buffer.from(new Uint8Array(arrayBuffer));

  fs.writeFileSync(outputPath, buffer);
  console.log(`Audio sauvegardé dans ${outputPath}`);
  return outputPath;
}

// Utilisation
await textToSpeech('Bonjour le monde!', './output.wav');

Options Multi-Voix

import ZAI from 'z-ai-web-dev-sdk';
import fs from 'fs';

async function generateWithVoice(text, voice, outputPath) {
  const zai = await ZAI.create();

  const response = await zai.audio.tts.create({
    input: text,
    voice: voice, // Voix disponibles : tongtong, chuichui, xiaochen, jam, kazi, douji, luodo
    speed: 1.0,
    response_format: 'wav',
    stream: false
  });

  // Get array buffer from Response object
  const arrayBuffer = await response.arrayBuffer();
  const buffer = Buffer.from(new Uint8Array(arrayBuffer));

  fs.writeFileSync(outputPath, buffer);
  return outputPath;
}

// Utilisation
await generateWithVoice('Bienvenue sur notre service', 'tongtong', './bienvenue.wav');

Vitesse Réglable

import ZAI from 'z-ai-web-dev-sdk';
import fs from 'fs';

async function generateWithSpeed(text, speed, outputPath) {
  const zai = await ZAI.create();

  // Plage de vitesse : 0,5 à 2,0 (contrainte de l'API)
  // 0,5 = moitié vitesse (plus lent)
  // 1,0 = vitesse normale (par défaut)
  // 2,0 = double vitesse (plus rapide)
  // Les valeurs en dehors de cette plage provoqueront des erreurs API

  const response = await zai.audio.tts.create({
    input: text,
    voice: 'tongtong',
    speed: speed,
    response_format: 'wav',
    stream: false
  });

  // Get array buffer from Response object
  const arrayBuffer = await response.arrayBuffer();
  const buffer = Buffer.from(new Uint8Array(arrayBuffer));

  fs.writeFileSync(outputPath, buffer);
  return outputPath;
}

// Utilisation - narration plus lente
await generateWithSpeed('Ceci est une annonce importante', 0.8, './lent.wav');

// Utilisation - narration plus rapide
await generateWithSpeed('Mise à jour rapide', 1.3, './rapide.wav');

Volume Réglable

import ZAI from 'z-ai-web-dev-sdk';
import fs from 'fs';

async function generateWithVolume(text, volume, outputPath) {
  const zai = await ZAI.create();

  // Plage de volume : supérieur à 0, jusqu'à 10 (contrainte de l'API)
  // Les valeurs doivent être > 0 (exclusif) et <= 10 (inclus)
  // Par défaut : 1,0 (volume normal)

  const response = await zai.audio.tts.create({
    input: text,
    voice: 'tongtong',
    speed: 1.0,
    volume: volume, // Paramètre optionnel
    response_format: 'wav',
    stream: false
  });

  // Get array buffer from Response object
  const arrayBuffer = await response.arrayBuffer();
  const buffer = Buffer.from(new Uint8Array(arrayBuffer));

  fs.writeFileSync(outputPath, buffer);
  return outputPath;
}

// Utilisation - audio plus fort
await generateWithVolume('Ceci est une annonce', 5.0, './fort.wav');

// Utilisation - audio plus silencieux
await generateWithVolume('Message chuchoté', 0.5, './silencieux.wav');

Cas d'Utilisation Avancés

Traitement par Lots

import ZAI from 'z-ai-web-dev-sdk';
import fs from 'fs';
import path from 'path';

async function batchTextToSpeech(textArray, outputDir) {
  const zai = await ZAI.create();
  const results = [];

  // Assurer que le répertoire de sortie existe
  if (!fs.existsSync(outputDir)) {
    fs.mkdirSync(outputDir, { recursive: true });
  }

  for (let i = 0; i < textArray.length; i++) {
    try {
      const text = textArray[i];
      const outputPath = path.join(outputDir, `audio_${i + 1}.wav`);

      const response = await zai.audio.tts.create({
        input: text,
        voice: 'tongtong',
        speed: 1.0,
        response_format: 'wav',
        stream: false
      });

      // Get array buffer from Response object
      const arrayBuffer = await response.arrayBuffer();
      const buffer = Buffer.from(new Uint8Array(arrayBuffer));

      fs.writeFileSync(outputPath, buffer);
      results.push({
        success: true,
        text,
        path: outputPath
      });
    } catch (error) {
      results.push({
        success: false,
        text: textArray[i],
        error: error.message
      });
    }
  }

  return results;
}

// Utilisation
const texts = [
  'Bienvenue au chapitre un',
  'Bienvenue au chapitre deux',
  'Bienvenue au chapitre trois'
];

const results = await batchTextToSpeech(texts, './audio-output');
console.log('Généré :', results.length, 'fichiers audio');

Génération de Contenu Dynamique

import ZAI from 'z-ai-web-dev-sdk';
import fs from 'fs';

class TTSGenerator {
  constructor() {
    this.zai = null;
  }

  async initialize() {
    this.zai = await ZAI.create();
  }

  async generateAudio(text, options = {}) {
    const {
      voice = 'tongtong',
      speed = 1.0,
      format = 'wav'
    } = options;

    const response = await this.zai.audio.tts.create({
      input: text,
      voice: voice,
      speed: speed,
      response_format: format,
      stream: false
    });

    // Get array buffer from Response object
    const arrayBuffer = await response.arrayBuffer();
    return Buffer.from(new Uint8Array(arrayBuffer));
  }

  async saveAudio(text, outputPath, options = {}) {
    const buffer = await this.generateAudio(text, options);
    if (buffer) {
      fs.writeFileSync(outputPath, buffer);
      return outputPath;
    }
    return null;
  }
}

// Utilisation
const generator = new TTSGenerator();
await generator.initialize();

await generator.saveAudio(
  'Bonjour, ceci est un test',
  './output.wav',
  { speed: 1.2 }
);

Exemple de Route API Next.js

import { NextRequest, NextResponse } from 'next/server';

export async function POST(req: NextRequest) {
  try {
    const { text, voice = 'tongtong', speed = 1.0 } = await req.json();

    // Importer le SDK ZAI
    const ZAI = (await import('z-ai-web-dev-sdk')).default;

    // Créer une instance SDK
    const zai = await ZAI.create();

    // Générer l'audio TTS
    const response = await zai.audio.tts.create({
      input: text.trim(),
      voice: voice,
      speed: speed,
      response_format: 'wav',
      stream: false,
    });

    // Get array buffer from Response object
    const arrayBuffer = await response.arrayBuffer();
    const buffer = Buffer.from(new Uint8Array(arrayBuffer));

    // Retourner l'audio comme réponse
    return new NextResponse(buffer, {
      status: 200,
      headers: {
        'Content-Type': 'audio/wav',
        'Content-Length': buffer.length.toString(),
        'Cache-Control': 'no-cache',
      },
    });
  } catch (error) {
    console.error('Erreur API TTS:', error);

    return NextResponse.json(
      {
        error: error instanceof Error ? error.message : 'Échec de la génération vocale, veuillez réessayer plus tard',
      },
      { status: 500 }
    );
  }
}

Bonnes Pratiques

1. Préparation du Texte

function prepareTextForTTS(text) {
  // Supprimer les espaces blancs excessifs
  text = text.replace(/\s+/g, ' ').trim();

  // Développer les abréviations courantes pour une meilleure prononciation
  const abbreviations = {
    'M.': 'Monsieur',
    'Mme': 'Madame',
    'Mlle': 'Mademoiselle',
    'etc.': 'et cetera'
  };

  for (const [abbr, full] of Object.entries(abbreviations)) {
    text = text.replace(new RegExp(abbr, 'g'), full);
  }

  return text;
}

2. Gestion des Erreurs

import ZAI from 'z-ai-web-dev-sdk';
import fs from 'fs';

async function safeTTS(text, outputPath) {
  try {
    // Valider l'entrée
    if (!text || text.trim().length === 0) {
      throw new Error('Le texte d\'entrée ne peut pas être vide');
    }

    if (text.length > 1024) {
      throw new Error('Le texte d\'entrée dépasse la longueur maximale de 1024 caractères');
    }

    const zai = await ZAI.create();

    const response = await zai.audio.tts.create({
      input: text,
      voice: 'tongtong',
      speed: 1.0,
      response_format: 'wav',
      stream: false
    });

    // Get array buffer from Response object
    const arrayBuffer = await response.arrayBuffer();
    const buffer = Buffer.from(new Uint8Array(arrayBuffer));

    fs.writeFileSync(outputPath, buffer);

    return {
      success: true,
      path: outputPath,
      size: buffer.length
    };
  } catch (error) {
    console.error('Erreur TTS:', error);
    return {
      success: false,
      error: error.message
    };
  }
}

3. Réutilisation de l'Instance SDK

import ZAI from 'z-ai-web-dev-sdk';

// Créer une instance singleton
let zaiInstance = null;

async function getZAIInstance() {
  if (!zaiInstance) {
    zaiInstance = await ZAI.create();
  }
  return zaiInstance;
}

// Utilisation
const zai = await getZAIInstance();
const response = await zai.audio.tts.create({ ... });

Cas d'Utilisation Courants

  1. Livres Audio & Podcasts : Convertir du contenu écrit au format audio
  2. E-learning : Créer des narrations pour du contenu éducatif
  3. Accessibilité : Fournir des versions audio de contenu textuel
  4. Assistants Vocaux : Générer des réponses dynamiques
  5. Annonces : Créer des notifications audio automatisées
  6. Systèmes IVR : Générer des invites pour les systèmes téléphoniques
  7. Localisation de Contenu : Créer de l'audio dans différentes langues

Exemples d'Intégration

Point d'Accès API Express.js

import express from 'express';
import ZAI from 'z-ai-web-dev-sdk';
import fs from 'fs';
import path from 'path';

const app = express();
app.use(express.json());

let zaiInstance;
const outputDir = './audio-output';

async function initZAI() {
  zaiInstance = await ZAI.create();
  if (!fs.existsSync(outputDir)) {
    fs.mkdirSync(outputDir, { recursive: true });
  }
}

app.post('/tts', async (req, res) => {
  try {
    const { text, voice = 'tongtong', speed = 1.0, format = 'wav' } = req.body;

    if (!text || text.trim().length === 0) {
      return res.status(400).json({ error: 'Le texte est requis' });
    }

    if (text.length > 1024) {
      return res.status(400).json({ error: 'Le texte dépasse la limite de 1024 caractères' });
    }

    const response = await zaiInstance.audio.tts.create({
      input: text.trim(),
      voice: voice,
      speed: speed,
      response_format: format,
      stream: false
    });

    const arrayBuffer = await response.arrayBuffer();
    const buffer = Buffer.from(new Uint8Array(arrayBuffer));

    const outputPath = path.join(outputDir, `tts_${Date.now()}.${format}`);
    fs.writeFileSync(outputPath, buffer);

    res.json({
      success: true,
      path: outputPath,
      size: buffer.length,
      format: format
    });

  } catch (error) {
    console.error('Erreur TTS:', error);
    res.status(500).json({
      success: false,
      error: error.message
    });
  }
});

app.listen(3000, () => {
  console.log('Serveur TTS démarré sur le port 3000');
  initZAI();
});

Configurations Avancées

Prise en Charge du Protocole WebSocket

import { WebSocketServer } from 'ws';
import ZAI from 'z-ai-web-dev-sdk';

const wss = new WebSocketServer({ port: 8080 });
let zai = null;

async function initZAI() {
  zai = await ZAI.create();
}

wss.on('connection', (ws) => {
  console.log('Client connecté');

  ws.on('message', async (message) => {
    try {
      const { text, voice = 'tongtong', speed = 1.0 } = JSON.parse(message);

      const response = await zai.audio.tts.create({
        input: text,
        voice: voice,
        speed: speed,
        response_format: 'pcm',
        stream: true
      });

      const reader = response.body.getReader();
      
      while (true) {
        const { done, value } = await reader.read();
        if (done) break;
        ws.send(value);
      }

      ws.send(JSON.stringify({ type: 'end' }));
    } catch (error) {
      ws.send(JSON.stringify({ type: 'error', message: error.message }));
    }
  });

  ws.on('close', () => {
    console.log('Client déconnecté');
  });
});

initZAI().then(() => {
  console.log('Serveur WebSocket TTS démarré sur le port 8080');
});

Contrôle du Cache

import crypto from 'crypto';
import fs from 'fs';
import path from 'path';

class TTSCache {
  constructor(cacheDir = './tts-cache') {
    this.cacheDir = cacheDir;
    if (!fs.existsSync(cacheDir)) {
      fs.mkdirSync(cacheDir, { recursive: true });
    }
  }

  generateKey(text, voice, speed) {
    const hash = crypto.createHash('md5');
    hash.update(`${text}:${voice}:${speed}`);
    return hash.digest('hex');
  }

  getCachedPath(key, format) {
    return path.join(this.cacheDir, `${key}.${format}`);
  }

  has(key, format) {
    return fs.existsSync(this.getCachedPath(key, format));
  }

  get(key, format) {
    const filePath = this.getCachedPath(key, format);
    if (fs.existsSync(filePath)) {
      return fs.readFileSync(filePath);
    }
    return null;
  }

  set(key, format, buffer) {
    fs.writeFileSync(this.getCachedPath(key, format), buffer);
  }
}

// Utilisation avec le SDK
const cache = new TTSCache();

async function generateCachedTTS(text, voice, speed, format = 'wav') {
  const cacheKey = cache.generateKey(text, voice, speed);
  
  if (cache.has(cacheKey, format)) {
    console.log('Utilisation de la version en cache');
    return cache.get(cacheKey, format);
  }

  const zai = await ZAI.create();
  const response = await zai.audio.tts.create({
    input: text,
    voice: voice,
    speed: speed,
    response_format: format,
    stream: false
  });

  const arrayBuffer = await response.arrayBuffer();
  const buffer = Buffer.from(new Uint8Array(arrayBuffer));
  
  cache.set(cacheKey, format, buffer);
  return buffer;
}

Dépannage

Problèmes Courants

  1. Erreur de Limite de Caractères

    • Cause : Le texte d'entrée dépasse 1024 caractères
    • Solution : Utiliser la fonction splitTextIntoChunks pour diviser le texte
  2. Erreur de Plage de Vitesse

    • Cause : La vitesse est en dehors de la plage [0.5, 2.0]
    • Solution : S'assurer que la vitesse est comprise entre 0.5 et 2.0
  3. Erreur de Plage de Volume

    • Cause : Le volume est inférieur ou égal à 0, ou supérieur à 10
    • Solution : S'assurer que le volume est > 0 et <= 10
  4. Format de Streaming Invalide

    • Cause : Utilisation d'un format autre que pcm avec le streaming activé
    • Solution : Utiliser pcm comme format lorsque stream: true
  5. Problèmes de Création de l'Instance SDK

    • Cause : Variables d'environnement ou authentification manquantes
    • Solution : Vérifier que les variables d'environnement requises (telles que ZAI_API_KEY) sont définies

Journalisation et Débogage

import ZAI from 'z-ai-web-dev-sdk';

async function debugTTS(text, options = {}) {
  console.log('Options de la requête TTS :', {
    text: {
      length: text.length,
      preview: text.substring(0, 50)
    },
    ...options
  });

  try {
    const zai = await ZAI.create();
    console.log('Instance SDK créée avec succès');

    const startTime = Date.now();
    const response = await zai.audio.tts.create({
      input: text,
      voice: options.voice || 'tongtong',
      speed: options.speed || 1.0,
      response_format: options.format || 'wav',
      stream: false
    });
    
    const arrayBuffer = await response.arrayBuffer();
    const buffer = Buffer.from(new Uint8Array(arrayBuffer));
    const duration = Date.now() - startTime;

    console.log('Résultat TTS :', {
      duration: `${duration}ms`,
      size: buffer.length,
      format: options.format || 'wav'
    });

    return buffer;
  } catch (error) {
    console.error('Échec TTS :', {
      message: error.message,
      stack: error.stack
    });
    throw error;
  }
}

Considérations de Sécurité

  1. Utilisation Côté Serveur : Toujours utiliser le SDK en backend uniquement. Ne jamais exposer les clés API dans le code client.
  2. Validation des Entrées : Valider et nettoyer les entrées texte avant traitement.
  3. Contrôle du Débit (Rate Limiting) : Implémenter un contrôle du débit pour éviter une utilisation abusive.
  4. Sauvegarde des Fichiers : Nettoyer régulièrement les fichiers audio temporaires.
  5. Gestion des Erreurs : Ne pas divulguer les détails internes dans les messages d'erreur côté client.

Référence de l'API

Paramètres de la Méthode create de zai.audio.tts

ParamètreTypeRequisPar DéfautDescription
inputstringOui-Texte à synthétiser (max 1024 caractères)
voicestringNon'tongtong'Identifiant de la voix à utiliser
speednumberNon1.0Vitesse de la parole (0.5 - 2.0)
volumenumberNon1.0Volume de la sortie (>0, <=10)
response_formatstringNon'wav'Format audio (wav, mp3, pcm)
streambooleanNonfalseActiver la sortie en streaming (nécessite le format pcm)

Voix Disponibles

Identifiant de VoixDescription
tongtongVoix féminine par défaut, claire et naturelle
chuichuiVoix féminine dynamique
xiaochenVoix féminine douce
jamVoix masculine, grave
kaziVoix masculine distinctive
doujiVoix féminine ludique
luodoVoix masculine naturelle

Individual skills in this repo

This repo contains 8 individual skills — each has its own dedicated page.

ARYAN2302/liquid_researcher

Generate a single-file Chinese atelier-style portfolio website (horizontal-row list + hover-reveal thumb interaction, art lishu typography "Alimama DaoLiTi" via CDN, light/dark theme, hash-routed detail pages). Takes a natural-language description of the studio (name, director, discipline, works) and outputs ONE working .html file. Runs in BOTH Claude Code (writes to ~/Desktop) and GLM / online chat (outputs HTML inline). Trigger phrases include "做个中式工作室作品集", "做个隶书作品集", "lishu-portfolio-gen ...", "做个白屋风格的作品集", or when user drags this skill folder into chat asking for an atelier-style site.

ARYAN2302/liquid_researcher

Chinese-market SaaS pricing page template — soft sky-blue glass-morphism, 4-tier card grid with one elevated "recommended" tier, monthly/annual toggle, FAQ accordion, ¥ pricing with Inter numerals, careful CJK linebreaking, ICP filing footer.

ARYAN2302/liquid_researcher

Premium calm-tech SaaS landing template — bilingual (CN/EN) literary voice over a dark forest-night palette with warm gold accent, Cormorant + Noto Serif SC, Three.js procedural forest hero, station-based scrolling narrative, custom cursor. Built for ambient-AI / creative-tool / philosophical SaaS, not loud commercial launch.

ARYAN2302/liquid_researcher

Pro-camera HUD mockup template — full-viewport black canvas wrapping a real video with monospace overlays (corner brackets, top status bar, side AF/exposure columns, bottom timecode + aperture/shutter/ISO row, vertical 8-filter wheel, animated reticle). For cinematographer portfolios, camera-app demos, LUT pack previews, filter-look auditions. NOT a TikTok/Reels mockup, NOT a storyboard, NOT a shot list, NOT a script document. The chrome wraps real footage — never a div placeholder.

ARYAN2302/liquid_researcher

Premium pre-launch waitlist page template — dark charcoal canvas with subtle vignette, drifting portrait video-thumbnail cards, fade-up cascades, glass nav, live-updating join counter, single email form with success/error states. Built for creative-tool / AI / niche-SaaS invite-only launches with hushed exclusive tone, not loud growth-marketing.

ARYAN2302/liquid_researcher

Route design-related HTML artifact tasks to the right artifact skill, reference, design system generation, or export skill.

ARYAN2302/liquid_researcher

Implement AI-powered video generation capabilities using the z-ai-web-dev-sdk. Use this skill when the user needs to generate videos from text prompts or images, create video content programmatically, or build applications that produce video outputs. Supports asynchronous task management with status polling and result retrieval.

ARYAN2302/liquid_researcher

Implement specialized video understanding capabilities using the z-ai-web-dev-sdk. Use this skill when the user needs to analyze video content, understand motion and temporal sequences, extract information from video frames, describe video scenes, or perform video-based AI analysis. Optimized for MP4, AVI, MOV, and other common video formats.

Skills associés