0. First Contact

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

🎶 Hey! I'm ready to help you arena ai. Send me a video file or just tell me what you need!

Try saying:

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

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. 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

1. 3. Acquire anonymous token:

   curl -s -X POST "$API/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.

1. 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.

Where Competitive Footage Meets Conversational Precision

Arena-ai was designed for one specific reality: event and sports video is dense, repetitive, and time-consuming to review manually. A two-hour match recording might contain thirty seconds of genuinely shareable content — and finding it traditionally means scrubbing through every minute yourself. Arena-ai changes that by letting you describe what you want in plain language and returning exactly those moments, trimmed and ready.

The skill connects to ClawHub's OpenClaw agent, which interprets your natural language requests and maps them against the video's temporal structure. Whether you're asking for 'every goal attempt in the second half' or 'crowd reactions after scoring plays,' the OpenClaw agent translates intent into precise edit instructions — no timeline manipulation required on your end.

Under the hood, arena-ai processes motion vectors, audio spikes, and scene composition data to build a structural map of your footage before you ask a single question. This pre-analysis means responses are fast and context-aware. Coaches building film sessions, esports teams reviewing tournament VODs, and live event producers cutting recap content all work within the same conversational loop — describe, refine, export.

Environment Variables

Variable	Required	Default
INLINECODE5	No	Auto-generated (100 free credits, expires in 7 days, revocable via Settings → API Tokens)
INLINECODE6

No | https://mega-api-prod.nemovideo.ai | | NEMO_WEB_URL | No | https://nemovideo.com | | NEMO_CLIENT_ID | No | Auto-generated UUID, persisted to ~/.config/nemovideo/client_id (UUID only, no secrets) | | SKILL_SOURCE | No | Auto-detected from install path, fallback unknown |

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 "$API/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 Requests to the Correct Endpoint

Use the table below to determine which endpoint handles each type of user request.

User says...	Action	Skip SSE
"export" / "导出" / "download" / "send me the video"	→ §3.5 Export	✅
"credits" / "积分" / "balance" / "余额"

→ §3.3 Credits | ✅ |
| "status" / "状态" / "show tracks" | → §3.4 State | ✅ |
| "upload" / "上传" / user sends file | → §3.2 Upload | ✅ |
| Everything else (generate, edit, add BGM…) | → §3.1 SSE | ❌ |

3. Primary Workflow Sequences

$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 INLINECODE26
• INLINECODE27 = this file's YAML frontmatter INLINECODE28
• INLINECODE29 = 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: INLINECODE35

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

3.0 Initializing a Session

curl -s -X POST "$API/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 work can begin, a session must be established with the backend. Every subsequent action within that conversation is tied to the session identifier returned at this step.

Open in browser: After creating a session, give the user a link to view/edit the task in NemoVideo:
INLINECODE36

3.1 Delivering Messages Over SSE

curl -s -X POST "$API/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 streamed to the client using Server-Sent Events, keeping the connection alive throughout processing.

SSE Handling

Event	Action
Text response	Apply GUI translation (§4), present to user
Tool call/result

Wait silently, don't forward | | heartbeat / empty data: | Keep waiting. Every 2 min: "⏳ Still working..." | | Stream closes | Process final response |

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 editing operations complete without returning any text in the SSE stream. When no text content is received, do not treat this as a failure. Instead: (1) check the task status endpoint to confirm completion, (2) retrieve the output asset URL directly, (3) present the result to the user as a successful edit, and (4) prompt the user for their next action.

Two-stage generation: When a raw video asset is produced, the backend automatically initiates a second processing stage that layers in background music and generates a title sequence. Treat these as two distinct phases: Phase 1 delivers the unprocessed video, and Phase 2 delivers the fully composed output. Wait for Phase 2 completion before surfacing the final result to the user.

3.2 Handling File Uploads

File upload: INLINECODE39

URL upload: INLINECODE40

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

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

Both video and image file types are accepted through the upload endpoint, enabling users to supply their own source media for editing.

3.3 Checking Available Credits

curl -s "$API/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 before initiating any generation task to confirm the user has a sufficient balance.

3.4 Polling Task Status

curl -s "$API/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:
CODEBLOCK7

3.5 Exporting and Delivering the Final Asset

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

Triggering an export does not deduct credits from the user's balance. The delivery sequence is: (a) call the export endpoint with the completed task ID, (b) poll until the export job reaches a terminal state, (c) retrieve the signed download URL from the response, (d) present the URL to the user with a clear call to action, and (e) log the export event to the session record.

b) Submit: INLINECODE52

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

c) Poll (every 30s, max 10 polls): INLINECODE55

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

d) Download from output.url → send to user. Fallback: $API/api/render/proxy/<id>/download.

e) When delivering the video, always also give the task detail link: INLINECODE60

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 recover gracefully: (1) Detect the disconnection event and immediately notify the user that the connection was interrupted. (2) Wait a minimum of three seconds before attempting to reconnect, to avoid thundering-herd conditions. (3) Re-establish the SSE connection using the original session ID and the last received event ID in the reconnection headers. (4) Poll the task status endpoint once to reconcile any events that may have been missed during the gap. (5) Resume normal streaming behavior and inform the user that the session has been restored.

4. Translating GUI Elements for the Backend

The backend operates under the assumption that all interactions originate from a graphical interface, so AI-layer instructions referencing UI components must be converted to their API equivalents before being forwarded.

Backend says	You do
"click [button]" / "点击"	Execute via API
"open [panel]" / "打开"

Show state via §3.4 |
| "drag/drop" / "拖拽" | Send edit via SSE |
| "preview in timeline" | Show track summary |
| "Export button" / "导出" | Execute §3.5 |
| "check account/billing" | Check §3.3 |

Keep content descriptions. Strip GUI actions.

5. Recommended Interaction Patterns

• Confirm intent before consuming credits — summarize what the edit will do and ask for user approval before dispatching any generation request.
• Surface progress incrementally — relay SSE progress events to the user in plain language so they understand the task is actively running.
• Handle ambiguity with a single clarifying question — when a user request could be interpreted multiple ways, ask one focused question rather than presenting a long list of options.
• Offer a next step after every completed output — once an asset is delivered, suggest a logical follow-on action such as exporting, refining, or sharing the result.
• Preserve context across turns — retain the session ID, task IDs, and asset URLs throughout the conversation so the user never has to repeat information.

6. Known Constraints and Limitations

• Maximum source video duration accepted by the backend is capped; files exceeding this limit will be rejected at upload time.
• Concurrent generation tasks per session are restricted; queue additional requests rather than firing them in parallel.
• The SSE stream does not guarantee ordered delivery under high-latency conditions; always reconcile final state via the status endpoint.
• Exported assets are available via signed URL for a limited window; advise users to download promptly before the link expires.
• Credit balances are read at request time and are not locked; a balance that appears sufficient may be consumed by another client before the task begins.

7. Error Handling Reference

The table below maps HTTP status codes and backend error identifiers to their recommended recovery actions.

Code	Meaning	Action
0	Success	Continue
1001

Bad/expired token | Re-auth via anonymous-token (tokens expire after 7 days) |
| 1002 | Session not found | New session §3.0 |
| 2001 | No credits | Anonymous: show registration URL with ?bind=<id> (get <id> from create-session or state response when needed). Registered: "Top up at nemovideo.ai" |
| 4001 | Unsupported file | Show supported formats |
| 4002 | File too large | Suggest compress/trim |
| 400 | Missing X-Client-Id | Generate Client-Id and retry (see §1) |
| 402 | Free plan export blocked | Subscription tier issue, NOT credits. "Register at nemovideo.ai to unlock export." |
| 429 | Rate limit (1 token/client/7 days) | Retry in 30s once |

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

Always verify that the API version in use matches the version this skill was written against before making any calls. Token scopes must include read and write permissions for sessions, tasks, and assets; a token missing any of these scopes will produce 403 responses on the affected endpoints. If a version mismatch is detected, surface a warning to the operator rather than proceeding silently.