Communitygithub.com

Cetc2211/AcTR-app - Génération Vidéo

Génération de vidéos par IA via le SDK z-ai-web-dev-sdk. Utilisez cette compétence pour créer des vidéos à partir de textes ou d'images, produire du contenu vidéo par programmation, ou intégrer des capacités de génération vidéo dans vos applications. Supporte la gestion asynchrone des tâches avec sondage d'état et récupération des résultats.

Qu'est-ce que AcTR-app - Génération Vidéo ?

Cette compétence guide la mise en œuvre de fonctionnalités de génération vidéo en utilisant le package z-ai-web-dev-sdk, permettant aux modèles d'IA de créer des vidéos à partir de descriptions textuelles ou d'images via un traitement asynchrone. Elle est idéale pour les développeurs qui souhaitent intégrer la génération de contenu vidéo dans leurs applications backend, avec des paramètres personnalisables comme la résolution, le taux d'images par seconde, la durée et la qualité. La compétence couvre à la fois l'utilisation en ligne de commande (CLI) avec l'outil `z-ai` pour des tâches simples et rapides, et l'utilisation avancée du SDK pour des workflows plus complexes et une intégration au sein d'applications web. Elle détaille les étapes pour un workflow de génération en deux temps : création d'une tâche avec un ID, puis sondage jusqu'à l'obtention des résultats, et inclut des exemples concrets pour la génération texte-vers-vidéo, image-vers-vidéo (avec recommandation forte d'utiliser des images encodées en base64), et la gestion d'images de début et de fin. La compétence s'applique aux plateformes où le SDK z-ai-web-dev-sdk est utilisé, en insistant sur le fait qu'il ne doit être employé que côté serveur.

Compatible avec~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/Cetc2211/AcTR-app/tree/HEAD/skills/video-generation

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 Génération Vidéo

Cette compétence guide la mise en œuvre de fonctionnalités de génération vidéo en utilisant le package z-ai-web-dev-sdk, permettant aux modèles d'IA de créer des vidéos à partir de descriptions textuelles ou d'images via un traitement asynchrone.

Chemin de la Compétence

Emplacement de la Compétence : {project_path}/skills/video-generation

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

Scripts de Référence : Des scripts de test d'exemple sont disponibles dans le répertoire {Emplacement de la Compétence}/scripts/ pour des tests rapides et une référence. Voir {Emplacement de la Compétence}/scripts/video.ts pour un exemple fonctionnel.

Aperçu

La Génération Vidéo permet de construire des applications capables de créer du contenu vidéo à partir de textes ou d'images, avec des paramètres personnalisables comme la résolution, le taux d'images par seconde, la durée et les réglages de qualité. L'API utilise un modèle asynchrone de tâches où vous créez une tâche et sondez les résultats.

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

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 (pour des Tâches Simples)

Pour des tâches simples de génération vidéo, vous pouvez utiliser la ligne de commande z-ai au lieu d'écrire du code. La CLI gère la création de la tâche et le sondage automatiquement, ce qui la rend idéale pour des tests rapides et de l'automatisation simple.

Texte-vers-Vidéo Basique

# Générer une vidéo avec sondage automatique
z-ai video --prompt "Un chat jouant avec une balle" --poll

# Utiliser des options courtes
z-ai video -p "Beau paysage avec des montagnes" --poll

Qualité et Réglages Personnalisés

# Mode qualité (vitesse ou qualité)
z-ai video -p "Vagues de l'océan au coucher du soleil" --quality quality --poll

# Résolution et FPS personnalisés
z-ai video \
  -p "Time-lapse de la ville" \
  --size "1920x1080" \
  --fps 60 \
  --poll

# Durée personnalisée (5 ou 10 secondes)
z-ai video -p "Feu d'artifice" --duration 10 --poll

Image-vers-Vidéo

IMPORTANT : Pour le paramètre image_url, il est fortement recommandé d'utiliser des données d'image encodées en base64 plutôt que des URLs. Cette approche est plus fiable et évite les problèmes de réseau ou de restrictions d'accès potentiels.

Note : Faites correspondre le type MIME dans l'URI de données à votre format d'image réel (image/jpeg, image/png, image/webp, etc.) pour éviter des problèmes de décodage.

# Générer une vidéo à partir d'une seule image en utilisant base64 (RECOMMANDÉ)
# Convertissez votre image en base64 avec le bon type MIME

# Pour les images PNG
IMAGE_BASE64=$(base64 -i image.png)
z-ai video \
  --image-url "data:image/png;base64,${IMAGE_BASE64}" \
  --prompt "Animer la scène" \
  --poll

# Pour les images JPEG
IMAGE_BASE64=$(base64 -i photo.jpg)
z-ai video \
  --image-url "data:image/jpeg;base64,${IMAGE_BASE64}" \
  --prompt "Animer la scène" \
  --poll

# Pour les images WebP
IMAGE_BASE64=$(base64 -i image.webp)
z-ai video \
  --image-url "data:image/webp;base64,${IMAGE_BASE64}" \
  --prompt "Animer la scène" \
  --poll

# Utilisation d'une URL (moins recommandée, peut avoir des problèmes de fiabilité)
z-ai video \
  -i "https://example.com/photo.jpg" \
  -p "Ajouter du mouvement à cette scène" \
  --poll

Mode Première-Dernière Image

IMPORTANT : Pour une meilleure fiabilité, utilisez des images encodées en base64 plutôt que des URLs. Assurez-vous que le type MIME correspond à votre format d'image réel.

# Générer une vidéo entre deux images en utilisant base64 (RECOMMANDÉ)
# Assurez-vous d'utiliser le bon type MIME pour chaque image

# Exemple avec des images PNG
START_BASE64=$(base64 -i start.png)
END_BASE64=$(base64 -i end.png)
z-ai video \
  --image-url "data:image/png;base64,${START_BASE64},data:image/png;base64,${END_BASE64}" \
  --prompt "Transition fluide entre les images" \
  --poll

# Exemple avec des images JPEG
START_BASE64=$(base64 -i start.jpg)
END_BASE64=$(base64 -i end.jpg)
z-ai video \
  --image-url "data:image/jpeg;base64,${START_BASE64},data:image/jpeg;base64,${END_BASE64}" \
  --prompt "Transition fluide entre les images" \
  --poll

# Utilisation d'URLs (moins recommandé)
z-ai video \
  --image-url "https://example.com/start.png,https://example.com/end.png" \
  --prompt "Transition fluide entre les images" \
  --poll

Avec Génération Audio

# Générer une vidéo avec des effets audio générés par IA
z-ai video \
  -p "Orage approchant" \
  --with-audio \
  --poll

Sauvegarder la Sortie

# Sauvegarder le résultat de la tâche dans un fichier JSON
z-ai video \
  -p "Lever du soleil sur les montagnes" \
  --poll \
  -o video_result.json

Paramètres de Sondage Personnalisés

# Personnaliser le comportement de sondage
z-ai video \
  -p "Robot dansant" \
  --poll \
  --poll-interval 10 \
  --max-polls 30

# Créer une tâche sans sondage (obtenir l'ID de tâche)
z-ai video -p "Animation d'art abstrait" -o task.json

Paramètres CLI

  • --prompt, -p <texte> : Optionnel - Description textuelle de la vidéo
  • --image-url, -i <données> : Optionnel - De préférence des données d'image encodées en base64 (par ex., "data:image/png;base64,iVBORw..."). Les URLs sont également supportées mais moins recommandées. Pour deux images, utilisez des valeurs séparées par des virgules.
  • --quality, -q <mode> : Optionnel - Mode de sortie : speed ou quality (par défaut : speed)
  • --with-audio : Optionnel - Générer des effets audio IA (par défaut : false)
  • --size, -s <résolution> : Optionnel - Résolution vidéo (par ex., "1920x1080")
  • --fps <taux> : Optionnel - Taux d'images par seconde : 30 ou 60 (par défaut : 30)
  • --duration, -d <secondes> : Optionnel - Durée : 5 ou 10 secondes (par défaut : 5)
  • --model, -m <modèle> : Optionnel - Nom du modèle à utiliser
  • --poll : Optionnel - Sondage automatique jusqu'à la fin de la tâche
  • --poll-interval <secondes> : Optionnel - Intervalle de sondage (par défaut : 5)
  • --max-polls <nombre> : Optionnel - Nombre maximum de tentatives de sondage (par défaut : 60)
  • --output, -o <chemin> : Optionnel - Chemin du fichier de sortie (format JSON)

Résolutions Supportées

  • 1024x1024
  • 768x1344
  • 864x1152
  • 1344x768
  • 1152x864
  • 1440x720
  • 720x1440
  • 1920x1080 (et autres résolutions standard)

Vérification de l'État de la Tâche Plus Tard

Si vous créez une tâche sans --poll, vous pouvez vérifier son état plus tard :

# Obtenir l'ID de tâche depuis la réponse initiale
z-ai async-result --id "task-id-ici" --poll

Quand Utiliser la CLI vs le SDK

Utilisez la CLI pour :

  • Tests rapides de génération vidéo
  • Création vidéo ponctuelle simple
  • Scripts d'automatisation en ligne de commande
  • Tester différents prompts et réglages

Utilisez le SDK pour :

  • Génération vidéo par lots avec logique personnalisée
  • Intégration avec des applications web
  • Gestion personnalisée de files d'attente de tâches
  • Applications de production avec des workflows complexes

Workflow de Génération Vidéo

La génération vidéo suit un motif asynchrone en deux étapes :

  1. Créer la Tâche : Soumettre une demande de génération vidéo et recevoir un ID de tâche
  2. Sonder les Résultats : Interroger l'état de la tâche jusqu'à son achèvement et récupérer l'URL vidéo

Mise en Œuvre Basique de la Génération Vidéo

Génération Texte-vers-Vidéo Simple

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

async function generateVideo(prompt) {
  try {
    const zai = await ZAI.create();

    // Créer une tâche de génération vidéo
    const task = await zai.video.generations.create({
      prompt: prompt,
      quality: 'speed', // 'speed' ou 'quality'
      with_audio: false,
      size: '1920x1080',
      fps: 30,
      duration: 5
    });

    console.log('ID de tâche :', task.id);
    console.log('État de la tâche :', task.task_status);

    // Sonder les résultats
    let result = await zai.async.result.query(task.id);
    let pollCount = 0;
    const maxPolls = 60;
    const pollInterval = 5000; // 5 secondes

    while (result.task_status === 'PROCESSING' && pollCount < maxPolls) {
      pollCount++;
      console.log(`Sondage ${pollCount}/${maxPolls} : L'état est ${result.task_status}`);
      await new Promise(resolve => setTimeout(resolve, pollInterval));
      result = await zai.async.result.query(task.id);
    }

    if (result.task_status === 'SUCCESS') {
      // Obtenir l'URL vidéo depuis plusieurs champs possibles
      const videoUrl = result.video_result?.[0]?.url ||
                      result.video_url ||
                      result.url ||
                      result.video;
      console.log('URL vidéo :', videoUrl);
      return videoUrl;
    } else {
      console.log('La tâche a échoué ou est toujours en cours de traitement');
      return null;
    }
  } catch (error) {
    console.error('La génération vidéo a échoué :', error.message);
    throw error;
  }
}

// Utilisation
const videoUrl = await generateVideo('Un chat joue avec une balle.');
console.log('Vidéo générée :', videoUrl);

Génération Image-vers-Vidéo

IMPORTANT : Le paramètre image_url accepte à la fois des données d'image encodées en base64 et des URLs, mais l'encodage base64 est fortement recommandé pour une meilleure fiabilité et pour éviter des problèmes liés au réseau.

Critique : Faites toujours correspondre le type MIME dans votre URI de données base64 au format d'image réel pour éviter des erreurs de décodage.

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

// Fonction utilitaire pour détecter le type MIME depuis l'extension du fichier
function getMimeType(filePath) {
  const ext = path.extname(filePath).toLowerCase();
  const mimeTypes = {
    '.jpg': 'image/jpeg',
    '.jpeg': 'image/jpeg',
    '.png': 'image/png',
    '.gif': 'image/gif',
    '.webp': 'image/webp',
    '.bmp': 'image/bmp'
  };
  return mimeTypes[ext] || 'image/jpeg'; // Par défaut JPEG si inconnu
}

async function generateVideoFromImage(imagePath, prompt) {
  const zai = await ZAI.create();

  // Méthode 1 : Utiliser une image encodée en base64 (RECOMMANDÉ)
  // Détecter automatiquement le type MIME depuis l'extension du fichier
  const imageBuffer = fs.readFileSync(imagePath);
  const mimeType = getMimeType(imagePath);
  const base64Image = `data:${mimeType};base64,${imageBuffer.toString('base64')}`;

  const task = await zai.video.generations.create({
    image_url: base64Image,  // Chaîne de données base64 avec le bon type MIME
    prompt: prompt,
    quality: 'quality',
    duration: 5,
    fps: 30
  });

  return task;
}

// Méthode 2 : Utiliser une URL (moins recommandée)
async function generateVideoFromImageUrl(imageUrl, prompt) {
  const zai = await ZAI.create();

  const task = await zai.video.generations.create({
    image_url: imageUrl,  // Chaîne URL
    prompt: prompt,
    quality: 'quality',
    duration: 5,
    fps: 30
  });

  return task;
}

// Exemples d'utilisation
const task1 = await generateVideoFromImage(
  './images/photo.jpg',  // Fonctionne avec JPEG
  'Animer cette scène avec un mouvement doux'
);

const task2 = await generateVideoFromImage(
  './images/graphic.png',  // Fonctionne avec PNG
  'Ajouter un mouvement dynamique'
);

const task3 = await generateVideoFromImage(
  './images/animation.webp',  // Fonctionne avec WebP
  'Donner vie à cette scène'
);

Image-vers-Vidéo avec Images de Début et de Fin

IMPORTANT : Pour le mode image clé, les images encodées en base64 sont fortement recommandées par rapport aux URLs pour garantir une génération vidéo cohérente et fiable. Utilisez toujours le bon type MIME pour chaque image.

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

// Fonction utilitaire pour détecter le type MIME depuis l'extension du fichier
function getMimeType(filePath) {
  const ext = path.extname(filePath).toLowerCase();
  const mimeTypes = {
    '.jpg': 'image/jpeg',
    '.jpeg': 'image/jpeg',
    '.png': 'image/png',
    '.gif': 'image/gif',
    '.webp': 'image/webp',
    '.bmp': 'image/bmp'
  };
  return mimeTypes[ext] || 'image/jpeg';
}

async function generateVideoWithKeyframes(startImagePath, endImagePath, prompt) {
  const zai = await ZAI.create();

  // Méthode 1 : Utiliser des images encodées en base64 (RECOMMANDÉ)
  // Détecter automatiquement le type MIME pour chaque image
  const startBuffer = fs.readFileSync(startImagePath);
  const endBuffer = fs.readFileSync(endImagePath);
  
  const startMimeType = getMimeType(startImagePath);
  const endMimeType = getMimeType(endImagePath);
  
  const startBase64 = `data:${startMimeType};base64,${startBuffer.toString('base64')}`;
  const endBase64 = `data:${endMimeType};base64,${endBuffer.toString('base64')}`;

  const task = await zai.video.generations.create({
    image_url: [startBase64, endBase64],  // Tableau de chaînes base64 avec les bons types MIME
    prompt: prompt,
    quality: 'quality',
    duration: 10,
    fps: 30
  });

  console.log('Tâche créée avec images clés :', task.id);
  return task;
}

// Méthode 2 : Utiliser des URLs (moins recommandée)
async function generateVideoWithKeyframesUrl(startImageUrl, endImageUrl, prompt) {
  const zai = await ZAI.create();

  const task = await zai.video.generations.create({
    image_url: [startImageUrl, endImageUrl],  // Tableau de chaînes URL
    prompt: prompt,
    quality: 'quality',
    duration: 10,
    fps: 30
  });

  console.log('Tâche créée avec images clés :', task.id);
  return task;
}

// Exemples d'utilisation avec différents formats
const task1 = await generateVideoWithKeyframes(
  './frames/start.jpg',  // Image de début JPEG
  './frames/end.jpg',    // Image de fin JPEG
  'Transition fluide entre ces scènes'
);

const task2 = await generateVideoWithKeyframes(
  './frames/start.png',  // Image de début PNG
  './frames/end.webp',   // Image de fin WebP - différents formats fonctionnent !
  'Effet de morphing entre les images'
);

Gestion des Résultats Asynchrones

Interroger l'État de la Tâche

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

async function checkTaskStatus(taskId) {
  try {
    const zai = await ZAI.create();
    const result = await zai.async.result.query(taskId);

    console.log('État de la tâche :', result.task_status);

    if (result.task_status === 'SUCCESS') {
      // Extraire l'URL vidéo du résultat
      const videoUrl = result.video_result?.[0]?.url ||
                      result.video_url ||
                      result.url ||
                      result.video;
      if (videoUrl) {
        console.log('URL vidéo :', videoUrl);
        return { success: true, url: videoUrl };
      }
    } else if (result.task_status === 'PROCESSING') {
      console.log('La tâche est toujours en cours de traitement');
      return { success: false, status: 'processing' };
    } else if (result.task_status === 'FAIL') {
      console.log('La tâche a échoué');
      return { success: false, status: 'failed' };
    }
  } catch (error) {
    console.error('Erreur lors de l\'interrogation de la tâche :', error.message);
    throw error;
  }
}

// Utilisation
const result = await checkTaskStatus('task-id-123');
if (result.success) {
  console.log('Vidéo prête à :', result.url);
}

Fonction de Sondage avec Timeout

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

async function pollForCompletion(taskId, maxPolls = 60, intervalMs = 5000) {
  const zai = await ZAI.create();
  
  for (let attempt = 1; attempt <= maxPolls; attempt++) {
    const result = await zai.async.result.query(taskId);
    
    console.log(`Tentative ${attempt}/${maxPolls} : ${result.task_status}`);
    
    switch (result.task_status) {
      case 'SUCCESS':
        return {
          success: true,
          url: result.video_result?.[0]?.url ||
               result.video_url ||
               result.url ||
               result.video,
          attempts: attempt
        };
      case 'FAIL':
        return {
          success: false,
          status: 'failed',
          attempts: attempt
        };
      case 'PROCESSING':
        if (attempt < maxPolls) {
          await new Promise(resolve => setTimeout(resolve, intervalMs));
        }
        break;
      default:
        return {
          success: false,
          status: result.task_status,
          attempts: attempt
        };
    }
  }
  
  return {
    success: false,
    status: 'timeout',
    attempts: maxPolls
  };
}

// Utilisation
const video = await pollForCompletion(taskId, 30, 10000);
if (video.success) {
  console.log('Vidéo générée :', video.url);
} else {
  console.log('Échec de la génération :', video.status);
}

Paramètres de Configuration

ParamètreTypeValeur par DéfautDescription
promptstring (optionnel)undefinedDescription textuelle de la vidéo souhaitée
image_urlstring ou string[] (optionnel)undefinedImage(s) source(s) - Recommandé : chaînes de données base64
qualitystring (optionnel)speedMode de qualité : speed ou quality
with_audioboolean (optionnel)falseGénérer des effets audio par IA
sizestring (optionnel)1024x1024Résolution vidéo (voir la section Résolutions Supportées)
fpsinteger (optionnel)30Taux d'images par seconde : 30 ou 60
durationinteger (optionnel)5Durée en secondes : 5 ou 10
modelstring (optionnel)undefinedNom du modèle spécifique

Note : Soit prompt, soit image_url doit être fourni. Les deux peuvent être utilisés ensemble pour générer des vidéos à partir d'images avec du mouvement guidé par texte.

Exemple de Script Complet

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

async function main() {
  try {
    const zai = await ZAI.create();
    
    // Étape 1 : Créer une tâche de génération vidéo
    console.log('Création de la tâche de génération vidéo...');
    
    const task = await zai.video.generations.create({
      prompt: 'Un paysage urbain futuriste avec des voitures volantes',
      quality: 'quality',
      size: '1920x1080',
      fps: 30,
      duration: 10
    });
    
    console.log('ID de tâche :', task.id);
    
    // Étape 2 : Sonder les résultats
    console.log('Sondage des résultats...');
    const result = await pollForCompletion(task.id, 30, 5000);
    
    if (result.success) {
      console.log('✅ Vidéo générée avec succès !');
      console.log('URL vidéo :', result.url);
      console.log('Nombre de tentatives :', result.attempts);
    } else {
      console.log('❌ La génération a échoué ou a expiré :', result.status);
    }
    
  } catch (error) {
    console.error('Erreur :', error.message);
    process.exit(1);
  }
}

async function pollForCompletion(taskId, maxPolls, intervalMs) {
  // ... (même que ci-dessus)
}

main();

Dépannage

Problèmes Courants

  1. Échec de la génération

    • Vérifiez que l'API est accessible
    • Assurez-vous que le prompt n'est pas vide et a du sens
    • Vérifiez que le format de l'image est supporté
  2. Timeout de la tâche

    • Augmentez maxPolls si la génération prend plus de temps que prévu
    • Vérifiez la charge du serveur API
  3. Erreurs de décodage d'image

    • Assurez-vous que le type MIME dans votre chaîne base64 correspond exactement au format de l'image
    • Utilisez la fonction getMimeType() fournie pour une détection automatique fiable du type
  4. URL vidéo manquante

    • L'URL vidéo peut être située dans différents champs du résultat selon l'API. Vérifiez toujours les champs suivants :
      • result.video_result[0]?.url
      • result.video_url
      • result.url
      • result.video

Meilleures Pratiques

  • Toujours utiliser des images encodées en base64 pour des paramètres fiables. Les URLs peuvent échouer en raison de restrictions réseau ou d'accès.
  • Mettre en œuvre une logique de nouvelle tentative pour les échecs de tâche
  • Utiliser des temps de sondage adaptés à votre cas d'utilisation (50 ms pour des tâches rapides, plus longs pour des tâches complexes)
  • Toujours vérifier result.task_status avant d'essayer d'accéder à l'URL vidéo

Individual skills in this repo

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

Cetc2211/AcTR-app

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.

Cetc2211/AcTR-app

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.

Cetc2211/AcTR-app

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.

Cetc2211/AcTR-app

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.

Cetc2211/AcTR-app

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

Cetc2211/AcTR-app

Implement text-to-speech (TTS) capabilities using the z-ai-web-dev-sdk. Use this skill when the user needs to convert text into natural-sounding speech, create audio content, build voice-enabled applications, or generate spoken audio files. Supports multiple voices, adjustable speed, and various audio formats.

Cetc2211/AcTR-app

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