Video: generation

# 1. Create the job
curl https://api.aitokens.ch/v1/videos \
  -H "Authorization: Bearer $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model": "wan-2.2-5b-fast", "prompt": "A green dragon flies over snowy mountains, wide cinematic shot"}'
# {"id": "video_01k6…", "object": "video", "status": "queued", "progress": 0, …}

# 2. Ask how it is going, every couple of seconds, until "completed" or "failed"
curl https://api.aitokens.ch/v1/videos/video_01k6… -H "Authorization: Bearer $API_KEY"

# 3. Download the clip
curl -o drago.mp4 https://api.aitokens.ch/v1/videos/video_01k6…/content -H "Authorization: Bearer $API_KEY"

{
  "id": "video_01k6zq3d2m8x4v5n7r9t0w2y4a",
  "object": "video",
  "model": "wan-2.2-5b-fast",
  "status": "queued",
  "progress": 0,
  "created_at": 1791302400,
  "completed_at": null,
  "expires_at": null,
  "error": null,
  "prompt": "A green dragon flies over snowy mountains, wide cinematic shot",
  "remixed_from_video_id": null,
  "seconds": "5",
  "size": "1280x704"
}

{"object": "list", "data": [ … ], "first_id": "video_…", "last_id": "video_…", "has_more": false}

{"id": "video_…", "object": "video.deleted", "deleted": true}

{"error": {"message": "'wan-2.2-5b-fast' makes clips of 5 seconds.", "type": "invalid_request_error", "param": "seconds", "code": "invalid_value"}}

import os, time, requests

API = "https://api.aitokens.ch/v1"
HEADERS = {"Authorization": f"Bearer {os.environ['API_KEY']}"}

def make_video(prompt: str, path: str, **options) -> dict:
    r = requests.post(f"{API}/videos", headers=HEADERS, json={"prompt": prompt, **options}, timeout=60)
    if r.status_code != 200:
        raise RuntimeError(r.json()["error"]["message"])
    job = r.json()

    while job["status"] in ("queued", "in_progress"):
        time.sleep(2)
        job = requests.get(f"{API}/videos/{job['id']}", headers=HEADERS, timeout=30).json()
        print(f"{job['status']} {job['progress']}%")

    if job["status"] == "failed":
        raise RuntimeError(job["error"]["message"])

    with requests.get(f"{API}/videos/{job['id']}/content", headers=HEADERS, stream=True, timeout=300) as clip:
        clip.raise_for_status()
        with open(path, "wb") as f:
            for chunk in clip.iter_content(1 << 16):
                f.write(chunk)
    return job

make_video("Isometric view of a cozy fantasy tavern, fireplace flickering, warm light", "taverna.mp4")

// volpe.mjs. Run: API_KEY=sk-… node volpe.mjs (.mjs: it is an ES module)
import { writeFile } from "node:fs/promises";

const API = "https://api.aitokens.ch/v1";
const headers = { Authorization: `Bearer ${process.env.API_KEY}` };
const sleep = (ms) => new Promise((r) => setTimeout(r, ms));

let res = await fetch(`${API}/videos`, {
  method: "POST",
  headers: { ...headers, "Content-Type": "application/json" },
  body: JSON.stringify({ prompt: "A low-poly red fox runs through an autumn forest, side view", size: "1280x704" }),
});
let job = await res.json();
if (!res.ok) throw new Error(job.error.message);

while (job.status === "queued" || job.status === "in_progress") {
  await sleep(Number(res.headers.get("openai-poll-after-ms") ?? 2000));
  res = await fetch(`${API}/videos/${job.id}`, { headers });
  job = await res.json();
}
if (job.status === "failed") throw new Error(job.error.message);

const clip = await fetch(`${API}/videos/${job.id}/content`, { headers });
if (!clip.ok) throw new Error((await clip.json()).error.message);
await writeFile("volpe.mp4", Buffer.from(await clip.arrayBuffer()));

// GeneraClip.cs: asks for a clip, waits for it, saves it and plays it. Unity 2022 LTS or Unity 6.
using System.Collections;
using System.IO;
using System.Text;
using UnityEngine;
using UnityEngine.Networking;
using UnityEngine.Video;

public class GeneraClip : MonoBehaviour
{
    public VideoPlayer player;
    const string Api = "https://api.aitokens.ch/v1";

    [System.Serializable] class Job { public string id; public string status; public int progress; public Err error; }
    [System.Serializable] class Err { public string code; public string message; }
    [System.Serializable] class Request { public string prompt; public string size; }

    // The key, from UserSettings/api_key.txt next to Assets/: never in a build, never in git.
    static string Key() =>
        File.ReadAllText(Path.Combine(Application.dataPath, "..", "UserSettings", "api_key.txt")).Trim();

    public IEnumerator Make(string prompt)
    {
        string key = Key();
        string body = JsonUtility.ToJson(new Request { prompt = prompt, size = "1280x704" });
        Job job;
        using (var post = new UnityWebRequest($"{Api}/videos", "POST"))
        {
            post.uploadHandler = new UploadHandlerRaw(Encoding.UTF8.GetBytes(body));
            post.downloadHandler = new DownloadHandlerBuffer();
            post.SetRequestHeader("Content-Type", "application/json");
            post.SetRequestHeader("Authorization", $"Bearer {key}");
            yield return post.SendWebRequest();
            if (post.result != UnityWebRequest.Result.Success) { Debug.LogError(post.downloadHandler.text); yield break; }
            job = JsonUtility.FromJson<Job>(post.downloadHandler.text);
        }

        while (job.status == "queued" || job.status == "in_progress")
        {
            yield return new WaitForSeconds(2);
            using (var get = UnityWebRequest.Get($"{Api}/videos/{job.id}"))
            {
                get.SetRequestHeader("Authorization", $"Bearer {key}");
                yield return get.SendWebRequest();
                if (get.result != UnityWebRequest.Result.Success) { Debug.LogError(get.downloadHandler.text); yield break; }
                job = JsonUtility.FromJson<Job>(get.downloadHandler.text);
            }
        }
        if (job.status != "completed") { Debug.LogError(job.error.message); yield break; }

        string path = Path.Combine(Application.persistentDataPath, $"{job.id}.mp4");
        using (var file = UnityWebRequest.Get($"{Api}/videos/{job.id}/content"))
        {
            file.SetRequestHeader("Authorization", $"Bearer {key}");
            file.downloadHandler = new DownloadHandlerFile(path);
            yield return file.SendWebRequest();
            if (file.result != UnityWebRequest.Result.Success)
            {
                // A file download handler has no .text: the error body went into the file.
                Debug.LogError($"{file.responseCode}: {file.error}");
                File.Delete(path);
                yield break;
            }
        }
        player.url = path;  // a local path works; the VideoPlayer switches to its URL source
        player.Play();
    }
}

import os
from openai import OpenAI

client = OpenAI(base_url="https://api.aitokens.ch/v1", api_key=os.environ["API_KEY"])
video = client.videos.create_and_poll(model="wan-2.2-5b-fast", prompt="A medieval castle on a hill at dawn, mist in the valley")
if video.status == "completed":
    client.videos.download_content(video.id).write_to_file("castello.mp4")

scenes = [
    "A knight in silver armour walks through a medieval village at sunset, camera following from behind",
    "The knight stops in front of a tavern door, warm light from inside",
    "Inside the tavern, people drinking at wooden tables, fireplace flickering",
]
for i, scene in enumerate(scenes, 1):
    make_video(scene, f"scena-{i:02d}.mp4", seed=42)