@acedatacloud/skills 2026.630.0 → 2026.630.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@acedatacloud/skills",
-  "version": "2026.630.0",
+  "version": "2026.630.2",
   "description": "Agent Skills for AceDataCloud AI services — music, image, video generation, LLM chat, web search. Compatible with Claude Code, GitHub Copilot, Gemini CLI, OpenAI Codex, and 30+ AI coding agents.",
   "keywords": [
     "agent-skills",

package/skills/ai-chat/SKILL.md

@@ -1,113 +1,81 @@
 ---
 name: ai-chat
-description: Access 50+ LLM models through a unified OpenAI-compatible API via AceDataCloud. Use when you need chat completions from GPT, Claude, Gemini, Kimi, Grok, or other models through a single endpoint. Supports streaming, function calling, and vision.
+description: Access 50+ LLM models through AceDataCloud's unified chat APIs. Use when you need OpenAI-compatible chat/responses calls or the newer `/aichat2/conversations` API across GPT, Claude, Gemini, Grok, Kimi, GLM, and DeepSeek models. Supports streaming, multimodal input, and tool calling.
 license: Apache-2.0
 metadata:
   author: acedatacloud
   version: "1.0"
-compatibility: Requires ACEDATACLOUD_API_TOKEN in .env file (see _shared/authentication.md). Works as a drop-in replacement for the OpenAI SDK.
+compatibility: Requires ACEDATACLOUD_API_TOKEN in .env file (see _shared/authentication.md). Works with OpenAI-compatible SDKs against the `/openai/*` routes.
 ---
 
 # AI Chat — Unified LLM Gateway
 
-Access 50+ language models through a single OpenAI-compatible endpoint via AceDataCloud.
+AceDataCloud exposes two documented chat surfaces:
+
+| Endpoint | Use For |
+|----------|---------|
+| `POST /aichat2/conversations` | Recommended stateful / multimodal / agentic conversations |
+| `POST /aichat/conversations` | Legacy conversation endpoint |
+| `POST /openai/chat/completions` | OpenAI-compatible stateless chat completions |
+| `POST /openai/responses` | OpenAI-compatible responses API |
 
 > **Setup:** See [authentication](../_shared/authentication.md) for token setup.
 
 ## Quick Start
 
+### Recommended: stateful conversations
+
 ```bash
-curl -X POST https://api.acedata.cloud/v1/chat/completions \
-  -H "Authorization: Bearer $ACEDATACLOUD_API_TOKEN" \
+curl -X POST https://api.acedata.cloud/aichat2/conversations \
+  -H "Authorization: ******ACEDATACLOUD_API_TOKEN" \
   -H "Content-Type: application/json" \
-  -d '{"model": "claude-sonnet-4-20250514", "messages": [{"role": "user", "content": "Hello!"}]}'
+  -d '{"model":"gpt-4.1","question":"Summarize the latest release notes.","stateful":true}'
 ```
 
-## OpenAI SDK Drop-in
+### OpenAI-compatible SDK
 
 ```python
 from openai import OpenAI
 
 client = OpenAI(
     api_key="your-token-here",
-    base_url="https://api.acedata.cloud/v1"
+    base_url="https://api.acedata.cloud/openai"
 )
 
 response = client.chat.completions.create(
-    model="gpt-4.1",
+    model="gpt-5.5",
     messages=[{"role": "user", "content": "Explain quantum computing"}]
 )
 print(response.choices[0].message.content)
 ```
 
-## Available Models
-
-### OpenAI GPT
-
-| Model | Type | Best For |
-|-------|------|----------|
-| `gpt-4.1` | Latest | General-purpose, high quality |
-| `gpt-4.1-mini` | Small | Fast, cost-effective |
-| `gpt-4.1-nano` | Tiny | Ultra-fast, lowest cost |
-| `gpt-4o` | Multimodal | Vision + text |
-| `gpt-4o-mini` | Small multimodal | Fast vision tasks |
-| `o1` | Reasoning | Complex reasoning tasks |
-| `o1-mini` | Small reasoning | Quick reasoning |
-| `o1-pro` | Pro reasoning | Advanced reasoning |
-| `gpt-5` | Latest gen | Next-gen intelligence |
-| `gpt-5.4` | Gen 5.4 | High-performance next-gen |
-| `gpt-5-mini` | Mini gen 5 | Fast next-gen |
-
-### Anthropic Claude
-
-| Model | Type | Best For |
-|-------|------|----------|
-| `claude-opus-4-8` | Latest Opus | Highest capability |
-| `claude-opus-4-6` | Latest Opus | Highest capability |
-| `claude-sonnet-4-6` | Latest Sonnet | Balanced quality/speed |
-| `claude-opus-4-5-20251101` | Opus 4.5 | Premium tasks |
-| `claude-sonnet-4-5-20250929` | Sonnet 4.5 | High-quality balance |
-| `claude-sonnet-4-20250514` | Sonnet 4 | Reliable general-purpose |
-| `claude-haiku-4-5-20251001` | Haiku 4.5 | Fast, efficient |
-| `claude-3-5-sonnet-20241022` | Legacy 3.5 | Proven track record |
-| `claude-3-opus-20240229` | Legacy Opus | Maximum quality (legacy) |
-
-### Google Gemini
-
-| Model | Best For |
-|-------|----------|
-| `gemini-1.5-pro` | Long context, complex tasks |
-| `gemini-1.5-flash` | Fast, efficient |
-
-### xAI Grok
-
-| Model | Best For |
-|-------|----------|
-| `grok-4` | Latest, highest capability |
-| `grok-3` | General-purpose |
-| `grok-3-fast` | Speed-optimized |
-| `grok-3-mini` | Compact, efficient |
-
-## Features
-
-### Streaming
+## Currently Documented Model Families
 
-```json
-POST /v1/chat/completions
-{
-  "model": "claude-sonnet-4-20250514",
-  "messages": [{"role": "user", "content": "Write a story"}],
-  "stream": true
-}
-```
+The OpenAPI specs expose a broad, fast-moving model catalog. Representative current
+models include:
+
+| Family | Current examples |
+|--------|------------------|
+| OpenAI / reasoning | `gpt-5.5`, `gpt-5.5-pro`, `gpt-5.4`, `gpt-5.4-pro`, `gpt-5.2`, `gpt-5.1`, `gpt-5`, `gpt-5-mini`, `gpt-5-nano`, `gpt-4.1`, `gpt-4.1-mini`, `gpt-4.1-nano`, `gpt-4o`, `gpt-4o-mini`, `o1`, `o3`, `o4-mini` |
+| OpenAI free-tier chat-completions | `gpt-5.5:free`, `gpt-5:free`, `gpt-4.1:free`, `gpt-4o:free`, `gpt-4o-mini:free`, `gpt-oss:free` |
+| Claude | `claude-opus-4-8`, `claude-opus-4-7`, `claude-opus-4-6`, `claude-opus-4-5-20251101`, `claude-sonnet-4-6`, `claude-sonnet-4-5-20250929`, `claude-sonnet-4-20250514`, `claude-haiku-4-5-20251001`, `claude-3-7-sonnet-20250219` |
+| Gemini | `gemini-3.1-pro`, `gemini-3.1-pro-preview`, `gemini-3.1-flash-image-preview`, `gemini-3.1-flash-lite-preview`, `gemini-3-pro-preview`, `gemini-2.5-flash-lite`, `gemini-2.0-flash-lite` |
+| Grok | `grok-4`, `grok-4-0709`, `grok-3`, `grok-3-fast` |
+| DeepSeek | `deepseek-r1`, `deepseek-r1-0528`, `deepseek-v3`, `deepseek-v3-250324`, `deepseek-v3.2-exp`, `deepseek-v4-flash` |
+| Kimi | `kimi-k2.5`, `kimi-k2-thinking-turbo`, `kimi-k2-thinking`, `kimi-k2-instruct-0905`, `kimi-k2-0905-preview`, `kimi-k2-turbo-preview`, `kimi-k2-0711-preview` |
+| GLM | `glm-5.2`, `glm-5.1`, `glm-5`, `glm-5-turbo`, `glm-4.7`, `glm-4.6`, `glm-4.5`, `glm-4.5v`, `glm-3-turbo` |
+
+`/aichat2/conversations` also accepts `model_group` values
+`chatgpt`, `claude`, `gemini`, `grok`, `kimi`, `glm`, and `deepseek`.
 
-### Function Calling
+## OpenAI-Compatible Chat
 
 ```json
-POST /v1/chat/completions
+POST /openai/chat/completions
 {
   "model": "gpt-4.1",
-  "messages": [{"role": "user", "content": "What's the weather in Tokyo?"}],
+  "messages": [{"role": "user", "content": "Write a haiku about observability."}],
+  "stream": true,
   "tools": [
     {
       "type": "function",
@@ -120,84 +88,61 @@ POST /v1/chat/completions
 }
 ```
 
-### Vision
-
-```json
-POST /v1/chat/completions
-{
-  "model": "gpt-4o",
-  "messages": [
-    {
-      "role": "user",
-      "content": [
-        {"type": "text", "text": "What's in this image?"},
-        {"type": "image_url", "image_url": {"url": "https://example.com/photo.jpg"}}
-      ]
-    }
-  ]
-}
-```
-
-## Parameters
+Common parameters:
 
 | Parameter | Type | Description |
 |-----------|------|-------------|
-| `model` | string | Model name (see tables above) |
-| `messages` | array | Array of `{role, content}` objects |
-| `temperature` | 0–2 | Randomness (default: 1) |
-| `top_p` | 0–1 | Nucleus sampling |
-| `max_tokens` | integer | Maximum output tokens |
+| `model` | string | One of the documented OpenAI-compatible models |
+| `messages` | array | Standard OpenAI chat message list |
+| `temperature` / `top_p` | number | Sampling controls |
+| `max_tokens` | integer | Output cap |
 | `stream` | boolean | Enable SSE streaming |
-| `tools` | array | Function calling definitions |
-| `tool_choice` | string/object | Tool selection strategy |
+| `tools` / `tool_choice` | array / string-object | Function-calling controls |
+| `service_tier` | string | Processing tier (`auto`, `default`, `flex`, `scale`, `priority`) |
+
+## Stateful / Agentic Conversations
 
-## Response
+`POST /aichat2/conversations` generalizes the legacy conversation API with
+multimodal user content, CRUD-style actions, and server-side conversation state.
 
 ```json
+POST /aichat2/conversations
 {
-  "id": "chatcmpl-xxx",
-  "object": "chat.completion",
-  "model": "claude-sonnet-4-20250514",
-  "choices": [
-    {
-      "index": 0,
-      "message": {"role": "assistant", "content": "Hello!"},
-      "finish_reason": "stop"
-    }
+  "action": "chat",
+  "model": "claude-sonnet-4-6",
+  "message": [
+    {"type": "text", "text": "Describe this image."},
+    {"type": "image_url", "image_url": {"url": "https://example.com/photo.jpg"}}
   ],
-  "usage": {
-    "prompt_tokens": 10,
-    "completion_tokens": 5,
-    "total_tokens": 15
-  }
+  "stateful": true,
+  "allowed_skills": ["google-search"],
+  "allowed_mcp_servers": ["mcp-google-search"]
 }
 ```
 
-## Gotchas
-
-- **100% OpenAI-compatible** — use the standard OpenAI SDK with `base_url="https://api.acedata.cloud/v1"`
-- Billing is token-based with per-model pricing (more expensive models cost more per token)
-- Vision is supported on multimodal models (`gpt-4o`, `gpt-4o-mini`, `grok-2-vision-*`)
-- Function calling works on most modern models (GPT-4+, Claude 3+)
-- Streaming returns `chat.completion.chunk` objects via SSE
-- `finish_reason` values: `"stop"` (complete), `"length"` (max tokens), `"tool_calls"` (function call), `"content_filter"` (filtered)
-
-## Stateful Conversations Endpoint
-
-For stateful, session-based chat (no need to send the full history each time), use `POST /aichat2/conversations` (recommended). `POST /aichat/conversations` remains available for legacy compatibility.
-
-```bash
-curl -X POST https://api.acedata.cloud/aichat2/conversations \
-  -H "Authorization: Bearer $ACEDATACLOUD_API_TOKEN" \
-  -H "Content-Type: application/json" \
-  -d '{"model": "gpt-4.1", "question": "What is quantum computing?", "stateful": true}'
-```
+Useful parameters:
 
 | Parameter | Type | Description |
 |-----------|------|-------------|
-| `model` | string | Model name (see Available Models above) |
-| `question` | string | The prompt or question to answer |
-| `id` | string | Conversation ID — pass the same ID to continue a session |
-| `preset` | string | Preset/system prompt for the conversation |
-| `stateful` | boolean | Enable stateful conversation (maintains history server-side) |
-| `references` | array | Additional context documents to include |
+| `action` | string | `chat`, `retrieve`, `retrieve_batch`, `update`, `delete` |
+| `model` | string | Model name |
+| `question` | string | Simple text prompt |
+| `message` | string or array | Multimodal content using `text`, `image_url`, or `file_url` items |
+| `stateful` | boolean | Keep conversation history server-side |
+| `references` | array | Extra context documents |
+| `preset` | string | Preset/system prompt |
+| `max_turns` | integer | Trim retained turn history |
+| `allowed_skills` / `allowed_mcp_servers` | array | Restrict tool-use scope |
+| `unattended_policy` | object | Tool-use permission policy |
+| `tool_results` | array | Return results for previously requested tool calls |
+| `model_group` | string | Family selector (`chatgpt`, `claude`, `gemini`, `grok`, `kimi`, `glm`, `deepseek`) |
+| `offset` / `limit` | integer | Pagination for retrieval actions |
+| `callback_url` / `async` | string / boolean | Async execution |
+
+## Gotchas
+
+- The documented OpenAI-compatible routes live under `/openai/*`, not `/v1/*`.
+- `POST /aichat2/conversations` is the recommended stateful endpoint; `POST /aichat/conversations` remains for legacy clients.
+- `message` on `/aichat2/conversations` can be multimodal (`text`, `image_url`, `file_url`); plain `question` still works for simple text prompts.
+- `action` on `/aichat2/conversations` is not chat-only — it also supports `retrieve`, `retrieve_batch`, `update`, and `delete`.
+- Free-tier model variants such as `gpt-5.5:free` are documented on `/openai/chat/completions`.

package/skills/fish-audio/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: fish-audio
-description: Generate AI text-to-speech audio and clone voices with Fish Audio via AceDataCloud API. Use when creating voiceover/narration audio (TTS), synthesizing speech, or cloning a reference voice. Chinese + multilingual.
+description: Generate AI text-to-speech audio with Fish Audio and browse public reference voices via AceDataCloud API. Use when creating voiceover/narration audio (TTS), synthesizing multilingual speech, or selecting a Fish reference voice from the model catalog.
 license: Apache-2.0
 metadata:
   author: acedatacloud
@@ -8,76 +8,111 @@ metadata:
 compatibility: Requires ACEDATACLOUD_API_TOKEN in .env file (see _shared/authentication.md).
 ---
 
-# Fish Audio — Text-to-Speech & Voice Cloning
+# Fish Audio — Text-to-Speech
 
-Generate narration / voiceover and clone voices through AceDataCloud's Fish Audio API.
+Generate narration / voiceover through AceDataCloud's Fish Audio API.
 
 > **Setup:** See [authentication](../_shared/authentication.md) for token setup.
 
-## Quick Start (TTS — synchronous, ~3s)
+## Quick Start
 
 ```bash
-curl -X POST https://api.acedata.cloud/fish/audios \
-  -H "Authorization: Bearer $ACEDATACLOUD_API_TOKEN" \
+curl -X POST https://api.acedata.cloud/fish/tts \
+  -H "Authorization: ******ACEDATACLOUD_API_TOKEN" \
   -H "Content-Type: application/json" \
-  -d '{"action":"speech","model":"fish-tts","voice_id":"543e4181d81b4ef6874b0e8fbdf27c78","prompt":"你好,欢迎使用 AceData Cloud。"}'
+  -H "model: s2-pro" \
+  -d '{"text":"你好，欢迎使用 AceData Cloud。","reference_id":"d7900c21663f485ab63ebdb7e5905036","format":"mp3"}'
 ```
 
-Response (synchronous — no polling needed for `speech`):
+Synchronous responses return a direct audio URL:
 
 ```json
-{"success": true, "data": [{"audio_url": "https://platform.r2.fish.audio/task/....mp3"}]}
+{"audio_url":"https://platform.r2.fish.audio/task/8a72ff9840234006a9f74cb2fa04f978.mp3"}
 ```
 
-→ download `data[0].audio_url`. `voice_id` is **required**. A good default Mandarin
-news-anchor voice is **`543e4181d81b4ef6874b0e8fbdf27c78`**.
-
 ## Endpoints
 
 | Endpoint | Purpose |
 |----------|---------|
-| `POST /fish/audios` | TTS (`action: "speech"`) — synchronous |
-| `POST /fish/voices` | List / register (clone) voices |
+| `POST /fish/tts` | Text-to-speech generation |
+| `GET /fish/model` | Browse/search public Fish reference voices |
+| `POST /fish/tasks` | Poll async TTS jobs when `async: true` |
 
 ## Workflows
 
-### 1. Text-to-Speech (the common case)
+### 1. Find a reference voice
+
+```bash
+curl "https://api.acedata.cloud/fish/model?page_size=10&page_number=1&title=Marcus" \
+  -H "Authorization: ******ACEDATACLOUD_API_TOKEN"
+```
+
+The response includes `items[]` with public voice metadata such as `_id`, `title`,
+`languages`, `tags`, `visibility`, and `state`. Use an item `_id` as
+`reference_id` in TTS requests.
+
+### 2. Text-to-Speech
 
 ```json
-POST /fish/audios
+POST /fish/tts
+Headers:
+  model: s2-pro
+
 {
-  "action": "speech",
-  "model": "fish-tts",
-  "voice_id": "543e4181d81b4ef6874b0e8fbdf27c78",
-  "prompt": "你的旁白文本。"
+  "text": "Your narration text.",
+  "reference_id": "d7900c21663f485ab63ebdb7e5905036",
+  "format": "mp3"
 }
 ```
 
-### 2. Clone a voice from a reference sample
+### 3. Async TTS
 
 ```json
-POST /fish/voices
+POST /fish/tts
+Headers:
+  model: s1
+
 {
-  "voice_url": "https://example.com/reference-voice.mp3",
-  "title": "My Custom Voice",
-  "description": "Clear, neutral-toned speaker"
+  "text": "Longer narration for background processing.",
+  "async": true,
+  "callback_url": "https://api.acedata.cloud/health"
 }
 ```
 
-Then pass the returned id as `voice_id` in workflow 1.
+> **Async:** See [async task polling](../_shared/async-tasks.md). Poll via `POST /fish/tasks` with `{"id":"..."}`.
+
+## Parameters — `/fish/tts`
+
+### Header
+
+| Parameter | Values | Description |
+|-----------|--------|-------------|
+| `model` | `"s1"`, `"s2-pro"` | Fish TTS engine selection |
 
-## Parameters — `/fish/audios`
+### JSON body
 
-| Parameter | Type | Required | Description |
-|-----------|------|----------|-------------|
-| `action` | string | yes | Use `"speech"` for TTS |
-| `model` | string | yes | `"fish-tts"` |
-| `voice_id` | string | yes | A Fish reference/cloned voice id (default Mandarin: `543e4181d81b4ef6874b0e8fbdf27c78`) |
-| `prompt` | string | yes | Text to synthesize |
+| Parameter | Type / Values | Description |
+|-----------|---------------|-------------|
+| `text` | string | Text to synthesize (required) |
+| `reference_id` | string | Public/reference voice ID from `GET /fish/model` |
+| `format` | `"mp3"`, `"wav"`, `"pcm"`, `"opus"` | Output format |
+| `sample_rate` | integer | Optional output sample rate |
+| `mp3_bitrate` | `64`, `128`, `192` | MP3 bitrate |
+| `opus_bitrate` | integer | Opus bitrate |
+| `latency` | `"normal"`, `"balanced"` | TTS latency mode |
+| `chunk_length` / `min_chunk_length` | integer | Chunking controls |
+| `temperature`, `top_p`, `repetition_penalty` | number | Sampling controls |
+| `max_new_tokens` | integer | Maximum generated tokens |
+| `normalize` | boolean | Normalize generated audio |
+| `prosody` | object | Prosody tuning |
+| `references` | array | Additional reference objects |
+| `callback_url` | string | Async callback URL |
+| `async` | boolean | Run asynchronously and poll `/fish/tasks` |
 
 ## Gotchas
 
-- **TTS (`action:"speech"`) is synchronous** — the response carries `data[0].audio_url`; do NOT poll `/fish/tasks` for it.
-- `voice_id` is **required** — a bare `{"prompt": "..."}` returns `400 voice_id is required when action is speech`.
-- `model` must be `"fish-tts"` for speech (NOT `speech-1.5`); sending a different model returns `400 model is invalid if action is speech`.
-- Pricing is based on the **byte count** of the generated audio. Multilingual is automatic.
+- The documented TTS endpoint is `POST /fish/tts` — not `/fish/audios`.
+- Choose the Fish engine with the **`model` request header**, not a JSON `model` field.
+- Use `reference_id` from `GET /fish/model` — not `voice_id`.
+- Synchronous requests return `audio_url` directly; async jobs should be polled via `/fish/tasks`.
+- The current OpenAPI spec documents voice browsing via `GET /fish/model`; it does **not** document a voice-cloning write endpoint.

package/skills/flux-image/SKILL.md

@@ -31,6 +31,7 @@ curl -X POST https://api.acedata.cloud/flux/images \
 |-------|---------|-------|-------|----------|
 | `flux-dev` | Good | Fast | 256–1440px | Quick generation (default) |
 | `flux-pro` | High | Medium | 256–1440px | Production work |
+| `flux-2-klein` | Good | Fastest | 256–1440px | Compact / lowest-latency Flux 2 generation |
 | `flux-2-flex` | High | Fast | 256–1440px | Faster high-quality generation |
 | `flux-2-pro` | Higher | Medium | 256–1440px | Better prompt following |
 | `flux-2-max` | Highest | Slow | 256–1440px | Maximum quality generation |
@@ -77,7 +78,8 @@ POST /flux/images
 - Use pixel dimensions (e.g., `"1024x1024"`) with dev/pro/flux-2 models, aspect ratios (e.g., `"16:9"`) with kontext models
 - Editing requires kontext models (`flux-kontext-pro` or `flux-kontext-max`) — other models only support generation
 - `count` parameter generates multiple images in one request (increases cost proportionally)
-- `flux-2-max` produces highest quality but is slowest — use dev/flex for iteration and max for final output
+- `flux-2-klein` is the lightest Flux 2 model — useful when latency matters more than peak quality
+- `flux-2-max` produces highest quality but is slowest — use dev/klein/flex for iteration and max for final output
 - All generation is async — always set `"callback_url"` to get a task id immediately, then poll `/flux/tasks` using `{"id":"<task_id>"}` or `{"ids":[...],"action":"retrieve_batch"}`
 
 > **MCP:** `pip install mcp-flux-pro` | Hosted: `https://flux.mcp.acedata.cloud/mcp` | See [all MCP servers](../_shared/mcp-servers.md)

package/skills/kling-video/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: kling-video
-description: Generate AI videos with Kuaishou Kling via AceDataCloud API. Use when creating videos from text or images, extending existing videos, applying motion control, or lip-syncing audio/text to video. Supports text-to-video, image-to-video, extend, motion generation, and lip-sync with multiple models and quality modes.
+description: Generate AI videos with Kuaishou Kling via AceDataCloud API. Use when creating videos from text or images, extending existing videos, applying motion control, animating a talking photo from image+audio, or lip-syncing audio/text to video. Supports text-to-video, image-to-video, extend, motion generation, talking-photo, and lip-sync with multiple models and quality modes.
 license: Apache-2.0
 metadata:
   author: acedatacloud
@@ -117,6 +117,21 @@ POST /kling/lip-sync
 }
 ```
 
+### 6. Talking Photo
+
+Animate a still portrait from an image plus an audio track.
+
+```json
+POST /kling/talking-photo
+{
+  "image_url": "https://example.com/portrait.jpg",
+  "audio_url": "https://example.com/voiceover.mp3",
+  "model": "kling-v2-1-master",
+  "duration": 5,
+  "mode": "pro"
+}
+```
+
 ## Parameters
 
 | Parameter | Values | Description |
@@ -143,6 +158,11 @@ POST /kling/lip-sync
 | `voice_id` (`/kling/lip-sync`) | string | Voice preset ID used in `text2video` |
 | `voice_language` (`/kling/lip-sync`) | `"zh"`, `"en"` | TTS language for `text2video` (default `zh`) |
 | `voice_speed` (`/kling/lip-sync`) | number | TTS speaking speed (default `1.0`) |
+| `image_url` (`/kling/talking-photo`) | URL | Source portrait image |
+| `audio_url` (`/kling/talking-photo`) | URL | Driving audio track |
+| `model` (`/kling/talking-photo`) | `"kling-v1"`, `"kling-v1-6"`, `"kling-v2-master"`, `"kling-v2-1-master"`, `"kling-v2-5-turbo"`, `"kling-v2-6"` | Talking-photo model |
+| `duration` (`/kling/talking-photo`) | `5`, `10` | Talking-photo duration |
+| `mode` (`/kling/talking-photo`) | `"std"`, `"pro"` | Talking-photo quality mode |
 
 ## Gotchas
 
@@ -152,6 +172,7 @@ POST /kling/lip-sync
 - `end_image_url` is only for `image2video` action — it defines the last frame
 - Motion control (`/kling/motion`) is a separate endpoint from video generation
 - Lip-sync is a separate endpoint (`/kling/lip-sync`) and requires `mode`; use `audio_url` for `audio2video` or `text` + voice fields for `text2video`
+- Talking-photo is a separate endpoint (`/kling/talking-photo`) and requires both `image_url` and `audio_url`
 - `pro` mode costs roughly 2x `std` mode but generates faster with better quality
 - Task states use `"succeed"` (not "succeeded") — check for this value when polling
 - `negative_prompt` helps avoid unwanted elements (e.g., "blurry, low quality, text")

package/skills/veo-video/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: veo-video
-description: Generate AI videos with Google Veo via AceDataCloud API. Use when creating videos from text descriptions, animating still images into video, upscaling/extending videos, re-shooting with new camera motion, or inserting/removing objects. Supports Veo 2, Veo 3, and Veo 3.1 models including fast variants.
+description: Generate AI videos with Google Veo via AceDataCloud API. Use when creating videos from text descriptions, animating still images into video, upscaling/extending videos, re-shooting with new camera motion, or inserting/removing objects. Supports Veo 2 Fast, Veo 3, and Veo 3.1 models including fast and ingredient variants.
 license: Apache-2.0
 metadata:
   author: acedatacloud
@@ -37,7 +37,6 @@ curl -X POST https://api.acedata.cloud/veo/tasks \
 
 | Model | Audio | Best For |
 |-------|-------|----------|
-| `veo2` | No | Cost-effective generation |
 | `veo2-fast` | No | Fast, cost-effective generation (default) |
 | `veo3` | Yes (native) | Full audiovisual generation |
 | `veo3-fast` | Yes (native) | Faster audiovisual generation |
@@ -69,7 +68,7 @@ POST /veo/videos
   "action": "image2video",
   "prompt": "the scene gently comes to life with wind and subtle motion",
   "image_urls": ["https://example.com/landscape.jpg"],
-  "model": "veo2",
+  "model": "veo2-fast",
   "aspect_ratio": "16:9"
 }
 ```
@@ -110,7 +109,7 @@ POST /veo/videos
 | `action` | `"text2video"`, `"image2video"`, `"ingredients2video"`, `"get1080p"` | Generation mode |
 | `model` | see Models table | Model to use (default: `veo2-fast`) |
 | `resolution` | `"4k"`, `"1080p"`, `"gif"` | Output resolution (default: 720p) |
-| `aspect_ratio` | `"16:9"`, `"9:16"`, `"1:1"`, `"4:3"`, `"3:4"` | Aspect ratio — only valid for `image2video` |
+| `aspect_ratio` | `"16:9"`, `"9:16"` | Aspect ratio — only valid for `image2video` |
 | `image_urls` | array of strings | Reference image URLs — for `image2video` (up to 2) or `ingredients2video` (up to 3) |
 | `video_id` | string | Video to upscale — only for `get1080p` |
 | `translation` | `true` / `false` | Auto-translate prompt to English (default: false) |
@@ -206,11 +205,12 @@ POST /veo/objects
 
 ## Gotchas
 
-- Veo 3 and 3.1 models generate **native audio** — `veo2`/`veo2-fast` do NOT support audio
+- Veo 3 and 3.1 models generate **native audio** — `veo2-fast` does NOT support audio
 - The `get1080p` action uses `video_id` (from a prior generation), not a URL
 - `aspect_ratio` is **only valid** for the `image2video` action
 - `image_urls` accepts an array — up to 2 images for `image2video`, up to 3 for `ingredients2video`
 - `veo31-fast-ingredients` **requires** image input — it cannot do text-only generation
+- Documented `aspect_ratio` values are only `"16:9"` and `"9:16"`
 - `translation: true` auto-translates Chinese or other non-English prompts before sending to Veo
 - Task polling uses `id` (not `task_id`) in the `/veo/tasks` request body
 - Task states use `"succeeded"` (not "completed") — check for this value when polling

package/skills/zhihu/SKILL.md

@@ -1,18 +1,19 @@
 ---
 name: zhihu
-description: Read and publish on Zhihu (知乎) with the user's own login cookies (BYOC) — list their published articles with vote/comment stats, inspect one article, and publish a new article. Use when the user mentions 知乎 / Zhihu, "我的知乎文章", reading their article stats (点赞/评论), or publishing/发文 to Zhihu.
+description: Read and publish on Zhihu (知乎) with the user's own login cookies (BYOC) — list published articles & answers with vote/comment stats, inspect an article/answer/question, publish an article, and answer or edit answers to questions. Use when the user mentions 知乎 / Zhihu, "我的知乎文章/回答", reading their stats (点赞/评论), 发文, or 回答/编辑某个问题的回答.
 when_to_use: |
   Trigger for anything on the user's Zhihu (知乎) account driven by their own
-  login cookie: show who they are, list their published articles with
-  vote-up / comment counts, look at one article's stats, or publish a new
-  article. This acts as the user's real account, so writes are gated behind
-  an explicit confirmation.
+  login cookie: show who they are, list their published articles or answers
+  with vote/comment counts, look at one article / answer / question, publish a
+  new article, post a new answer to a question, or edit an existing answer.
+  This acts as the user's real account, so writes are gated behind an explicit
+  confirmation.
 connections: [zhihu]
 allowed_tools: [Bash]
 license: Apache-2.0
 metadata:
   author: acedatacloud
-  version: "1.1"
+  version: "1.2"
 ---
 
 # zhihu — read & publish on Zhihu via your own cookies
@@ -37,6 +38,9 @@ BLOG=$SKILL_DIR/scripts/blog.py
 python3 $BLOG whoami                       # who is logged in
 python3 $BLOG articles --limit 20          # my published articles + stats
 python3 $BLOG article <article-id>         # one article's details + stats
+python3 $BLOG answers --limit 20           # my published answers + stats
+python3 $BLOG answer <answer-id>           # one answer's details + stats
+python3 $BLOG question <question-id>       # a question's info + whether I answered it
 ```
 
 ## Verify the connection first
@@ -56,11 +60,21 @@ extension). Do **not** retry in a loop.
 |---|---|
 | Who am I | `python3 $BLOG whoami` |
 | My latest articles + vote/comment counts | `python3 $BLOG articles --limit 20` |
-| Next page | `python3 $BLOG articles --limit 20 --offset 20` |
+| My latest answers + like/favorite/comment counts | `python3 $BLOG answers --limit 20` |
+| Next page (any list) | add `--offset 20` |
 | One article's stats | `python3 $BLOG article <id>` |
+| One answer's stats (incl. 赞同 voteup) | `python3 $BLOG answer <id>` |
+| A question's info + my answer id (if any) | `python3 $BLOG question <id>` |
 
-Stats come straight from Zhihu: `voteup_count` (赞同), `comment_count` (评论).
-Zhihu does not expose per-article read counts on these endpoints.
+Article stats: `voteup_count` (赞同), `comment_count` (评论). Zhihu does not
+expose per-article read counts on these endpoints.
+
+**Answer stat caveat:** the `answers` *list* endpoint does **not** return
+`voteup_count` (赞同) — it only exposes `like_count` (喜欢), `favorite_count`
+(收藏) and `comment_count`. For the authoritative 赞同 count of an answer, call
+`answer <id>` (the single-answer endpoint returns `voteup_count`). `question <id>`
+reports `already_answered` + `my_answer_id` so you know whether to use
+`answer-question` (new) or `edit-answer` (update).
 
 ## Publishing — GATED (dry-run unless trailing `--confirm`)
 
@@ -88,10 +102,46 @@ python3 $BLOG publish --title "标题" --content-file article.html --confirm
   reports `images_found`. Pass `--no-images` to skip this. So you can hand the
   CLI HTML/Markdown with normal public image URLs and the pictures survive.
 
+## Answering questions — GATED (dry-run unless trailing `--confirm`)
+
+Two write commands cover the question/answer side. Both gate exactly like
+`publish`: no trailing `--confirm` → **dry-run**; `--confirm` is honored **only
+as the last argument**. Always show the dry-run, get an explicit "yes", then
+re-run with `--confirm` last.
+
+```sh
+# Content is HTML (same as articles). For Markdown, convert to HTML first.
+
+# Post a NEW answer to a question
+python3 $BLOG answer-question --question <qid> --content-file ans.html                       # dry-run
+python3 $BLOG answer-question --question <qid> --content-file ans.html --draft-only --confirm  # PRIVATE draft (safe)
+python3 $BLOG answer-question --question <qid> --content-file ans.html --confirm               # PUBLIC, goes live
+
+# Edit an EXISTING answer (replaces its live, public content)
+python3 $BLOG edit-answer --id <answer-id> --content-file ans.html             # dry-run
+python3 $BLOG edit-answer --id <answer-id> --content-file ans.html --confirm   # overwrites live answer
+```
+
+- **One answer per question.** Zhihu allows a single answer per user per
+  question. If the user already answered, `answer-question --confirm` returns a
+  clear error telling you to use `edit-answer` instead — find the existing answer
+  id with `answers` or `question <qid>` (which reports `my_answer_id`).
+- **`--draft-only` is the safe path for new answers** — it saves a *private*
+  draft on the question (nothing public). The user reviews it on Zhihu, then you
+  re-run without `--draft-only` (with `--confirm`) to publish. Prefer this unless
+  the user clearly asked to go live immediately.
+- **`edit-answer` has no private mode** — the answer is already public, so any
+  `--confirm` edit is live immediately. It preserves the answer's current repost
+  setting unless you override with `--repost allowed|disallowed`.
+- **转载授权** (`--repost allowed|disallowed`): new answers default to
+  `disallowed` (don't grant repost rights); editing keeps the current setting.
+- **Images are auto-hosted** for answers too — same behavior and `--no-images`
+  flag as `publish`.
+
 ## Gotchas — surface before the user is surprised
 
-- **This is the user's real Zhihu account.** Confirm before any publish; reading
-  exposes their own private drafts.
+- **This is the user's real Zhihu account.** Confirm before any publish / answer /
+  edit; reading exposes their own private drafts.
 - **Cookie expiry**: Zhihu cookies are short-lived. A `401`/`403` means
   reconnect at auth.acedata.cloud/user/connections — never loop-retry.
 - **ToS**: cookie automation is against most platforms' terms. This only ever

package/skills/zhihu/scripts/blog.py

@@ -165,6 +165,12 @@ ZH = {
     "articles": "https://www.zhihu.com/api/v4/members/{token}/articles",
     "article": "https://www.zhihu.com/api/v4/articles/{id}",
     "create_draft": "https://zhuanlan.zhihu.com/api/articles/drafts",
+    # Answers (回答) — the question/answer side of Zhihu, distinct from articles.
+    "member_answers": "https://www.zhihu.com/api/v4/members/{token}/answers",
+    "answer": "https://www.zhihu.com/api/v4/answers/{id}",
+    "question": "https://www.zhihu.com/api/v4/questions/{id}",
+    "question_answers": "https://www.zhihu.com/api/v4/questions/{id}/answers",
+    "question_draft": "https://www.zhihu.com/api/v4/questions/{id}/draft",
 }
 ZH_FETCH = {"x-requested-with": "fetch"}
 
@@ -245,6 +251,141 @@ def cmd_article(jar, args):
     out(res)
 
 
+# ── Answers (回答) ───────────────────────────────────────────────────
+#
+# Answers are Zhihu's question/answer side, separate from articles. A user has
+# at most ONE answer per question (a second POST returns RepeatedActionException
+# 103003 — surface that and point at edit-answer). Writes go through the same
+# cookie-only web APIs as articles; no x-zse signature is required.
+
+ZH_ANSWER_LIST_INCLUDE = (
+    "data[*].comment_count,created_time,updated_time,question"
+)
+
+
+def _fmt_answer(a: dict) -> dict:
+    aid = a.get("id")
+    q = a.get("question") or {}
+    qid = q.get("id")
+    # The member/answers endpoint never returns voteup_count (赞同); it only
+    # exposes like_count / favorites under reaction.statistics. The authoritative
+    # 赞同 count lives on the single-answer detail endpoint (`answer <id>`).
+    react = (a.get("reaction") or {}).get("statistics") or {}
+    return {
+        "answer_id": str(aid) if aid is not None else None,
+        "question_id": str(qid) if qid is not None else None,
+        "question_title": q.get("title"),
+        "url": (f"https://www.zhihu.com/question/{qid}/answer/{aid}" if (qid and aid) else None),
+        "voteup_count": a.get("voteup_count"),
+        "like_count": react.get("like_count"),
+        "favorite_count": react.get("favorites"),
+        "comment_count": a.get("comment_count"),
+        "created_time": a.get("created_time"),
+        "updated_time": a.get("updated_time"),
+    }
+
+
+def cmd_answers(jar, args):
+    me = zh_me(jar)
+    token = me.get("url_token")
+    if not token:
+        die("Zhihu profile has no url_token; cannot list answers.")
+    url = ZH["member_answers"].format(token=token)
+    q = urllib.parse.urlencode({
+        "include": ZH_ANSWER_LIST_INCLUDE,
+        "limit": args.limit,
+        "offset": args.offset,
+    })
+    _, data = get_json(f"{url}?{q}", jar, headers=ZH_FETCH)
+    items = data.get("data", []) if isinstance(data, dict) else []
+    out({
+        "total": (data.get("paging") or {}).get("totals") if isinstance(data, dict) else None,
+        "count": len(items),
+        "answers": [_fmt_answer(a) for a in items],
+    })
+
+
+def cmd_answer(jar, args):
+    base = ZH["answer"].format(id=args.id)
+    q = urllib.parse.urlencode({
+        "include": "content,voteup_count,comment_count,created_time,updated_time,question",
+    })
+    _, a = get_json(f"{base}?{q}", jar, headers=ZH_FETCH)
+    if not isinstance(a, dict) or not a.get("id"):
+        die(f"answer {args.id} not found or not accessible: {str(a)[:300]}")
+    res = _fmt_answer(a)
+    res["content_excerpt"] = (a.get("excerpt") or "")[:200]
+    out(res)
+
+
+def cmd_question(jar, args):
+    base = ZH["question"].format(id=args.id)
+    q = urllib.parse.urlencode({
+        "include": "answer_count,follower_count,visit_count,comment_count,detail",
+    })
+    _, qd = get_json(f"{base}?{q}", jar, headers=ZH_FETCH)
+    if not isinstance(qd, dict) or not (qd.get("id") or qd.get("title")):
+        die(f"question {args.id} not found or not accessible: {str(qd)[:300]}")
+    # Detect whether the logged-in user already answered this question so the
+    # caller knows to use `edit-answer` instead of `answer-question`.
+    mine = _my_answer_for_question(jar, args.id)
+    out({
+        "question_id": str(qd.get("id") or args.id),
+        "title": qd.get("title"),
+        "url": f"https://www.zhihu.com/question/{args.id}",
+        "answer_count": qd.get("answer_count"),
+        "follower_count": qd.get("follower_count"),
+        "visit_count": qd.get("visit_count"),
+        "detail_excerpt": _strip_tags(qd.get("detail") or "")[:300],
+        "my_answer_id": mine,
+        "already_answered": bool(mine),
+    })
+
+
+_TAG_RE = re.compile(r"<[^>]+>")
+
+
+def _strip_tags(html: str) -> str:
+    return _TAG_RE.sub("", html or "").strip()
+
+
+def _my_answer_for_question(jar, question_id: str):
+    """Return the logged-in user's answer id for a question, or None.
+
+    Scans the *user's own* answers (bounded by their answer count) and matches
+    on question id. This is reliable even for popular questions — unlike walking
+    the question's own answer list, which may have thousands of entries. For an
+    account with more answers than the scan cap this is best-effort.
+    """
+    me = zh_me(jar)
+    token = me.get("url_token")
+    if not token:
+        return None
+    url = ZH["member_answers"].format(token=token)
+    qid = str(question_id)
+    offset = 0
+    for _ in range(15):  # up to 300 of the user's own answers
+        q = urllib.parse.urlencode({
+            "include": "data[*].question",
+            "limit": 20,
+            "offset": offset,
+        })
+        status, data = request("GET", f"{url}?{q}", jar, headers=ZH_FETCH)
+        try:
+            data = json.loads(data)
+        except json.JSONDecodeError:
+            return None
+        items = data.get("data", []) if isinstance(data, dict) else []
+        for a in items:
+            if str((a.get("question") or {}).get("id")) == qid:
+                return str(a.get("id"))
+        if (data.get("paging") or {}).get("is_end", True) or not items:
+            return None
+        offset += 20
+    return None
+
+
+
 # ── Image re-hosting ────────────────────────────────────────
 #
 # Zhihu silently drops any <img> whose src is not on its own CDN, so external
@@ -539,11 +680,187 @@ def cmd_publish(jar, args):
     })
 
 
+def _read_content(args) -> str:
+    content = args.content
+    if args.content_file:
+        try:
+            with open(args.content_file, encoding="utf-8") as f:
+                content = f.read()
+        except OSError as e:
+            die(f"cannot read --content-file: {e}")
+    if content is None:
+        die("provide --content-file <path> or --content <html>")
+    return content
+
+
+def _reshipment(value):
+    # Zhihu accepts "allowed" / "disallowed" for 转载授权 (repost permission).
+    return value if value in ("allowed", "disallowed") else None
+
+
+def cmd_answer_question(jar, args):
+    """Post a NEW answer to a question (GATED). --draft-only saves a private draft."""
+    qid = args.question
+    if not qid:
+        die("--question <question-id> is required")
+    content = _read_content(args)
+    # Fetch the question title so the dry-run shows what is being answered.
+    title = None
+    try:
+        _, qd = get_json(
+            f"{ZH['question'].format(id=qid)}?{urllib.parse.urlencode({'include': 'title'})}",
+            jar, headers=ZH_FETCH,
+        )
+        title = qd.get("title") if isinstance(qd, dict) else None
+    except SystemExit:
+        raise
+    except Exception:
+        pass
+
+    reship = _reshipment(args.repost) or "disallowed"
+
+    if not CONFIRM:
+        out({
+            "dry_run": True,
+            "command": "answer-question",
+            "platform": "zhihu",
+            "question_id": str(qid),
+            "question_title": title,
+            "draft_only": args.draft_only,
+            "reshipment_settings": reship,
+            "content_bytes": len(content),
+            "images_found": count_images(content),
+            "note": "re-run with --confirm as the LAST argument to actually write. "
+                    "Without --draft-only this publishes a PUBLIC answer on the user's real "
+                    "account. One answer per question — if you already answered, use edit-answer.",
+        })
+        return
+
+    image_stats = {"found": 0, "rehosted": 0, "failed": 0}
+    if not args.no_images:
+        content, image_stats = rehost_images(jar, content)
+
+    if args.draft_only:
+        # Private autosave draft on the question — nothing goes public.
+        status, text = request(
+            "PUT", ZH["question_draft"].format(id=qid), jar,
+            headers=ZH_FETCH, body={"content": content, "delta_time": 5},
+        )
+        if status >= 400:
+            die(f"save-draft failed ({status}) for question {qid}: {text[:300]}")
+        out({
+            "ok": True,
+            "draft_only": True,
+            "question_id": str(qid),
+            "images": image_stats,
+            "review_url": f"https://www.zhihu.com/question/{qid}",
+            "note": "Private draft saved. Open the question to review, then re-run "
+                    "without --draft-only (and --confirm) to publish.",
+        })
+        return
+
+    status, text = request(
+        "POST", ZH["question_answers"].format(id=qid), jar,
+        headers=ZH_FETCH, body={"content": content, "reshipment_settings": reship},
+    )
+    try:
+        res = json.loads(text)
+    except json.JSONDecodeError:
+        res = {}
+    if status >= 400:
+        # Zhihu's `error` is usually a dict {code, name, message} but can be a
+        # bare string; guard both. `code` may arrive as int or str.
+        err = res.get("error") if isinstance(res, dict) and isinstance(res.get("error"), dict) else {}
+        if str(err.get("code")) == "103003":
+            die(
+                f"you already answered question {qid}; Zhihu allows one answer per "
+                f"question. Find your answer id with `answers` and use "
+                f"`edit-answer --id <answer-id>` instead."
+            )
+        die(f"publish answer failed ({status}) for question {qid}: {text[:300]}")
+    aid = res.get("id") if isinstance(res, dict) else None
+    if not aid:
+        die(f"publish answer returned no id ({status}): {text[:300]}")
+    out({
+        "ok": True,
+        "published": True,
+        "question_id": str(qid),
+        "answer_id": str(aid),
+        "images": image_stats,
+        "url": f"https://www.zhihu.com/question/{qid}/answer/{aid}",
+    })
+
+
+def cmd_edit_answer(jar, args):
+    """Edit an EXISTING answer's content (GATED). The answer stays public."""
+    aid = args.id
+    if not aid:
+        die("--id <answer-id> is required")
+    content = _read_content(args)
+    # Read the current answer to preserve its repost setting and show context.
+    cur = {}
+    try:
+        _, cur = get_json(
+            f"{ZH['answer'].format(id=aid)}?{urllib.parse.urlencode({'include': 'reshipment_settings,question'})}",
+            jar, headers=ZH_FETCH,
+        )
+    except SystemExit:
+        raise
+    except Exception:
+        cur = {}
+    if not isinstance(cur, dict):
+        cur = {}
+    # Keep the answer's current repost setting; if it couldn't be read and the
+    # user gave no override, fall back to the conservative "disallowed" rather
+    # than silently granting repost rights.
+    reship = _reshipment(args.repost) or cur.get("reshipment_settings") or "disallowed"
+    q = cur.get("question") or {}
+
+    if not CONFIRM:
+        out({
+            "dry_run": True,
+            "command": "edit-answer",
+            "platform": "zhihu",
+            "answer_id": str(aid),
+            "question_title": q.get("title"),
+            "reshipment_settings": reship,
+            "content_bytes": len(content),
+            "images_found": count_images(content),
+            "note": "re-run with --confirm as the LAST argument to actually overwrite. "
+                    "This replaces the live, public answer's content on the user's real account.",
+        })
+        return
+
+    image_stats = {"found": 0, "rehosted": 0, "failed": 0}
+    if not args.no_images:
+        content, image_stats = rehost_images(jar, content)
+
+    status, text = request(
+        "PUT", ZH["answer"].format(id=aid), jar,
+        headers=ZH_FETCH, body={"content": content, "reshipment_settings": reship},
+    )
+    if status >= 400:
+        die(f"edit answer failed ({status}) for {aid}: {text[:300]}")
+    qid = q.get("id")
+    out({
+        "ok": True,
+        "edited": True,
+        "answer_id": str(aid),
+        "images": image_stats,
+        "url": (f"https://www.zhihu.com/question/{qid}/answer/{aid}" if qid else None),
+    })
+
+
 COMMANDS = {
     "whoami": cmd_whoami,
     "articles": cmd_articles,
     "article": cmd_article,
     "publish": cmd_publish,
+    "answers": cmd_answers,
+    "answer": cmd_answer,
+    "question": cmd_question,
+    "answer-question": cmd_answer_question,
+    "edit-answer": cmd_edit_answer,
 }
 
 
@@ -571,6 +888,38 @@ def main() -> None:
     sp.add_argument("--no-images", action="store_true",
                     help="skip re-hosting external images to Zhihu's CDN")
 
+    sp = sub.add_parser("answers", help="list the user's published answers + stats")
+    sp.add_argument("--limit", type=int, default=20)
+    sp.add_argument("--offset", type=int, default=0)
+
+    sp = sub.add_parser("answer", help="one answer's details + stats")
+    sp.add_argument("id")
+
+    sp = sub.add_parser("question", help="a question's info + whether you already answered it")
+    sp.add_argument("id")
+
+    sp = sub.add_parser("answer-question",
+                        help="post a NEW answer to a question (GATED by trailing --confirm)")
+    sp.add_argument("--question", help="question id to answer")
+    sp.add_argument("--content", help="HTML content inline")
+    sp.add_argument("--content-file", help="path to an HTML file")
+    sp.add_argument("--draft-only", action="store_true",
+                    help="save a private draft on the question; do NOT go public")
+    sp.add_argument("--repost", choices=["allowed", "disallowed"],
+                    help="转载授权: allow or disallow reposting (default disallowed)")
+    sp.add_argument("--no-images", action="store_true",
+                    help="skip re-hosting external images to Zhihu's CDN")
+
+    sp = sub.add_parser("edit-answer",
+                        help="overwrite an existing answer's content (GATED by trailing --confirm)")
+    sp.add_argument("--id", help="answer id to edit")
+    sp.add_argument("--content", help="HTML content inline")
+    sp.add_argument("--content-file", help="path to an HTML file")
+    sp.add_argument("--repost", choices=["allowed", "disallowed"],
+                    help="转载授权: override repost permission (default keeps current)")
+    sp.add_argument("--no-images", action="store_true",
+                    help="skip re-hosting external images to Zhihu's CDN")
+
     args = p.parse_args(ARGV)
     jar = load_cookies(args.platform)
     COMMANDS[args.command](jar, args)