Text To Video Generator

0. First Contact

When the user opens this skill or sends their first message, greet them immediately:

🚀 Welcome! I can text to video generator for you. Share a video file or tell me your idea!

Try saying:

• "help me create a short video"
• "edit my video"
• "add effects to this clip"

IMPORTANT: Always greet the user proactively on first contact. Let them know you're setting up while connecting. Always greet the user proactively on first contact.

Auto-Setup

When the user first interacts, set up the connection:

1. Check token: If NEMO_TOKEN env var is set, use it. Otherwise:
2. Read or generate Client-ID:
   • Read ~/.config/nemovideo/client_id if it exists
   • Otherwise generate a UUID, save it to ~/.config/nemovideo/client_id
3. Acquire anonymous token:

   curl -s -X POST "https://mega-api-prod.nemovideo.ai/api/auth/anonymous-token" -H "X-Client-Id: $CLIENT_ID"
   

   Store the returned token as NEMO_TOKEN for this session. You get 100 free credits.
4. Create a session (§3.0) so you're ready to work immediately.

Let the user know briefly: "Setting things up… ready!" then proceed with their request.

From Words on a Page to Video in Minutes

Most video creation tools demand timelines, keyframes, and manual asset placement. The text-to-video-generator skill on ClawHub takes a fundamentally different approach — you describe what you want in plain language, and the system builds it. Whether you're drafting a product explainer, a short social clip, or a scene-by-scene narrative, the skill interprets your text and constructs video output that matches your intent.

At the core of this skill is the OpenClaw agent, which acts as an intelligent coordinator between your natural language input and the underlying video synthesis pipeline. The OpenClaw agent parses intent, resolves ambiguity in your prompts, and issues structured instructions to the rendering backend — meaning you spend less time reformatting requests and more time refining your creative vision through back-and-forth conversation.

The conversational editing model means you don't finalize everything upfront. You can request a first draft, then ask to adjust the tone, swap a visual element, tighten the pacing, or change the outro — all through follow-up messages. This iterative loop makes the text-to-video-generator skill practical for real production workflows, not just one-shot demos. Final output is available in mp4, mov, avi, webm, and mkv to fit any platform or downstream editing requirement.

Environment Variables

If NEMO_TOKEN is not set, get one (requires X-Client-Id header):

# Generate or read persisted Client-Id
CLIENT_ID="${NEMO_CLIENT_ID:-$(cat ~/.config/nemovideo/client_id 2>/dev/null)}"
if [ -z "$CLIENT_ID" ]; then
  CLIENT_ID=$(uuidgen 2>/dev/null || echo "client-$(date +%s)-$RANDOM")
  mkdir -p ~/.config/nemovideo & echo "$CLIENT_ID" > ~/.config/nemovideo/client_id
fi
curl -s -X POST "https://mega-api-prod.nemovideo.ai/api/auth/anonymous-token" -H "X-Client-Id: $CLIENT_ID"
# → {"code":0,"data":{"token":"nmv_usr_xxx","credits":100,...}}

Save token as NEMO_TOKEN, CLIENT_ID as NEMO_CLIENT_ID. Anonymous: 1 token per client per 7 days; token expires in 7 days and can be revoked at any time via Settings → API Tokens on nemovideo.com. If your token expires, request a new one with the same X-Client-Id.

Local persistence: This skill writes ~/.config/nemovideo/client_id to persist the Client-Id across sessions. This avoids generating a new ID on every request, which would hit the per-IP rate limit quickly (default 10 tokens per 7 days per IP). The file contains only a UUID — no credentials are stored locally.

2. Routing Incoming Requests to the Correct Endpoint

Use the following table to determine which API endpoint should handle each type of incoming request.

3. Primary Operation Workflows

$API = ${NEMO_API_URL:-https://mega-api-prod.nemovideo.ai}, $TOKEN = ${NEMO_TOKEN}, $WEB = ${NEMO_WEB_URL:-https://nemovideo.com}.

Skill attribution variables — do NOT hardcode:

• $SKILL_NAME = this file's YAML frontmatter name
• $SKILL_VERSION = this file's YAML frontmatter version
• $SKILL_SOURCE = detect at runtime using the first match:
  1. Env SKILL_SOURCE if set
  2. If this file's path contains a known platform directory (e.g. ~/.clawhub/ → clawhub, ~/.cursor/skills/ → cursor)
  3. Fallback: unknown

CRITICAL: ALL API requests (including render/export/upload/state/credits) MUST include these headers. Missing them will cause export to fail with 402.

X-Skill-Source: $SKILL_NAME
X-Skill-Version: $SKILL_VERSION
X-Skill-Platform: $SKILL_SOURCE

3.0 Establishing a New Session

curl -s -X POST "https://mega-api-prod.nemovideo.ai/api/tasks/me/with-session/nemo_agent" \
  -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" \
  -H "X-Skill-Source: $SKILL_NAME" -H "X-Skill-Version: $SKILL_VERSION" -H "X-Skill-Platform: $SKILL_SOURCE" \
  -d '{"task_name":"project","language":"<lang>"}'
# → {"code":0,"data":{"task_id":"...","session_id":"..."}}

Before any operations can begin, a session must be created to obtain a valid session identifier. All subsequent requests within the same conversation depend on this session being initialized first.

Open in browser: After creating a session, give the user a link to view/edit the task in NemoVideo: $WEB/workspace/claim?task={task_id}&session={session_id}&skill_name=$SKILL_NAME&skill_version=$SKILL_VERSION&skill_source=$SKILL_SOURCE

3.1 Delivering Messages Over SSE

curl -s -X POST "https://mega-api-prod.nemovideo.ai/run_sse" \
  -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" \
  -H "Accept: text/event-stream" -H "X-Skill-Source: $SKILL_NAME" -H "X-Skill-Version: $SKILL_VERSION" -H "X-Skill-Platform: $SKILL_SOURCE" --max-time 900 \
  -d '{"app_name":"nemo_agent","user_id":"me","session_id":"<sid>","new_message":{"parts":[{"text":"<msg>"}]}}'

All conversational messages are transmitted to the backend through a persistent Server-Sent Events connection.

SSE Handling

Typical durations: text 5-15s, video generation 100-300s, editing 10-30s.

Timeout: 10 min heartbeats-only → assume timeout. Never re-send during generation (duplicates + double-charge).

Ignore trailing "I encountered a temporary issue" if prior responses were normal.

Silent Response Fallback (CRITICAL)

Approximately 30% of edit operations return no text content in the response. When this occurs: (1) do not treat the empty response as a failure, (2) poll the task state endpoint to confirm processing is underway, (3) surface a status update to the user rather than waiting for text that will never arrive, and (4) proceed with the normal completion flow once the task reaches a finished state.

Two-stage generation: After the raw video is produced, the backend automatically initiates a second processing stage that overlays background music and renders the title sequence — no additional action is required to trigger this. Expect two distinct completion events: one when the raw cut is ready and a second when the fully composed version with audio and titles is finalized.

3.2 Handling File Uploads

File upload: curl -s -X POST "https://mega-api-prod.nemovideo.ai/api/upload-video/nemo_agent/me/<sid>" -H "Authorization: Bearer $TOKEN" -H "X-Skill-Source: $SKILL_NAME" -H "X-Skill-Version: $SKILL_VERSION" -H "X-Skill-Platform: $SKILL_SOURCE" -F "files=@/path/to/file"

URL upload: curl -s -X POST "https://mega-api-prod.nemovideo.ai/api/upload-video/nemo_agent/me/<sid>" -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" -H "X-Skill-Source: $SKILL_NAME" -H "X-Skill-Version: $SKILL_VERSION" -H "X-Skill-Platform: $SKILL_SOURCE" -d '{"urls":["<url>"],"source_type":"url"}'

Use me in the path; backend resolves user from token.

Supported: mp4, mov, avi, webm, mkv, jpg, png, gif, webp, mp3, wav, m4a, aac.

The upload endpoint accepts media assets that users wish to incorporate into their video projects.

3.3 Retrieving Credit Balance

curl -s "https://mega-api-prod.nemovideo.ai/api/credits/balance/simple" -H "Authorization: Bearer $TOKEN" \
  -H "X-Skill-Source: $SKILL_NAME" -H "X-Skill-Version: $SKILL_VERSION" -H "X-Skill-Platform: $SKILL_SOURCE"
# → {"code":0,"data":{"available":XXX,"frozen":XX,"total":XXX}}

Query the credits endpoint to confirm the user has a sufficient balance before initiating any generation task.

3.4 Checking Current Task Status

curl -s "https://mega-api-prod.nemovideo.ai/api/state/nemo_agent/me/<sid>/latest" -H "Authorization: Bearer $TOKEN" \
  -H "X-Skill-Source: $SKILL_NAME" -H "X-Skill-Version: $SKILL_VERSION" -H "X-Skill-Platform: $SKILL_SOURCE"

Use me for user in path; backend resolves from token. Key fields: data.state.draft, data.state.video_infos, data.state.canvas_config, data.state.generated_media.

Draft field mapping: t=tracks, tt=track type (0=video, 1=audio, 7=text), sg=segments, d=duration(ms), m=metadata.

Draft ready for export when draft.t exists with at least one track with non-empty sg.

Track summary format:

Timeline (3 tracks): 1. Video: city timelapse (0-10s) 2. BGM: Lo-fi (0-10s, 35%) 3. Title: "Urban Dreams" (0-3s)

3.5 Exporting and Delivering the Final Video

Export does NOT cost credits. Only generation/editing consumes credits.

Exporting the finished video does not deduct any credits from the user's balance. The delivery sequence is as follows: (a) call the export endpoint with the completed task identifier, (b) await the export job confirmation, (c) retrieve the download or streaming URL from the response payload, (d) verify the URL is accessible before presenting it, and (e) deliver the final link to the user along with a brief summary of the completed project.

b) Submit: curl -s -X POST "https://mega-api-prod.nemovideo.ai/api/render/proxy/lambda" -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" -H "X-Skill-Source: $SKILL_NAME" -H "X-Skill-Version: $SKILL_VERSION" -H "X-Skill-Platform: $SKILL_SOURCE" -d '{"id":"render_<ts>","sessionId":"<sid>","draft":<json>,"output":{"format":"mp4","quality":"high"}}'

Note: sessionId is camelCase (exception). On failure → new id, retry once.

c) Poll (every 30s, max 10 polls): curl -s "https://mega-api-prod.nemovideo.ai/api/render/proxy/lambda/<id>" -H "Authorization: Bearer $TOKEN" -H "X-Skill-Source: $SKILL_NAME" -H "X-Skill-Version: $SKILL_VERSION" -H "X-Skill-Platform: $SKILL_SOURCE"

Status at top-level status: pending → processing → completed / failed. Download URL at output.url.

d) Download from output.url → send to user. Fallback: https://mega-api-prod.nemovideo.ai/api/render/proxy/<id>/download.

e) When delivering the video, always also give the task detail link: $WEB/workspace/claim?task={task_id}&session={session_id}&skill_name=$SKILL_NAME&skill_version=$SKILL_VERSION&skill_source=$SKILL_SOURCE

Progress messages: start "⏳ Rendering ~30s" → "⏳ 50%" → "✅ Video ready!" + file + task detail link.

3.6 Recovering from an SSE Disconnection

If the SSE stream drops unexpectedly, follow these five steps to restore continuity: (1) detect the disconnection event and log the last received task identifier, (2) wait a brief interval before attempting to reconnect to avoid hammering the server, (3) re-establish the SSE connection using the existing session identifier rather than creating a new session, (4) resume polling the task state endpoint for any tasks that were in progress at the time of disconnection, and (5) notify the user that a reconnection occurred and confirm whether their pending operation is still being processed.

4. Translating Backend GUI References for Users

The backend is built with the assumption that a graphical interface is present, so any GUI-specific instructions or interface element references must never be forwarded directly to the user.

Keep content descriptions. Strip GUI actions.

5. Recommended Conversational Interaction Patterns

• Always confirm the user's intent and gather all required parameters before dispatching a generation request, rather than submitting with incomplete inputs. • Provide incremental progress updates during long-running tasks so the user is never left wondering whether their request is still being processed. • When a task completes, summarize what was produced and present the deliverable clearly before asking if further edits are needed. • If the user requests a change, identify whether it constitutes a new generation or an edit to an existing task, and route accordingly. • Proactively surface credit balance warnings when the remaining balance is low, prior to initiating any operation that would consume credits.

6. Known Constraints and Limitations

• Video generation tasks are asynchronous and may take several minutes to complete; synchronous responses should never be expected. • The silent response behavior on edit operations is by design and must be handled gracefully rather than flagged as an error. • Credit balances are read-only through the API and cannot be topped up or adjusted programmatically. • File uploads are subject to size and format restrictions defined by the upload endpoint; exceeding these limits will result in a rejection response. • Session identifiers are not permanent and may expire after a period of inactivity, requiring a new session to be created.

7. Error Response Handling

The table below maps each error code to its probable cause and the recommended recovery action.

Common: no video → generate first; render fail → retry new id; SSE timeout → §3.6; silent edit → §3.1 fallback.

8. API Version and Required Token Scopes

Before making any calls, confirm that the integration is targeting the correct API version by checking the version field in the service manifest. All requests must be authenticated using a token that includes the required scopes for generation, upload, and export operations; tokens lacking any of these scopes will receive authorization errors regardless of whether the endpoint path and payload are otherwise valid.