@cliptude/cli 0.1.12 → 0.1.14
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +18 -0
- package/cliptude_mcp/cli.py +58 -1
- package/cliptude_mcp/client.py +51 -2
- package/cliptude_mcp/server.py +121 -5
- package/package.json +1 -1
- package/pyproject.toml +1 -1
package/README.md
CHANGED
|
@@ -71,6 +71,24 @@ footage under every beat, the transition on each cut, two-image reveals, and fre
|
|
|
71
71
|
lists the graphics, `transitions`, `reveal_styles` and `sounds` (with previews). The plan schema and rules are in
|
|
72
72
|
`skills/cliptude-plan/SKILL.md`. The job costs the same as the website price.
|
|
73
73
|
|
|
74
|
+
### Product videos from a store
|
|
75
|
+
|
|
76
|
+
Turn a store product into a 6 to 60 minute educational YouTube video: about 80% teaching, then the product, with its
|
|
77
|
+
real photos composited into the closing boards (never regenerated). Any Shopify product URL works with no setup; other
|
|
78
|
+
stores work through the page's structured data; a store connected at cliptude.com/integrations/stores/ (or that
|
|
79
|
+
installed the Cliptude Shopify app) can also be searched.
|
|
80
|
+
|
|
81
|
+
```
|
|
82
|
+
cliptude product fetch https://store.com/products/handle # product_id + 3 angles
|
|
83
|
+
cliptude product script <product-id> --angle 1 --duration 10-12 --discount-code YOUTUBE15
|
|
84
|
+
cliptude product status <job-id> # until script_ready; review the script
|
|
85
|
+
cliptude product render <job-id> --aspect-ratio 16:9 # returns at once
|
|
86
|
+
cliptude product status <job-id> # until ready_for_review; open editor_url
|
|
87
|
+
```
|
|
88
|
+
|
|
89
|
+
MCP tools: `fetch_product_context`, `draft_product_script`, `render_product_video`, `get_product_video_status`.
|
|
90
|
+
None of them waits for a render; poll the status tool.
|
|
91
|
+
|
|
74
92
|
`--title` is required. Provide **one** of `--prompt`, `--script` / `--script-file`, `--voiceover`, or `--talking-head`. Never copy the title into `--prompt`. If you only have a topic, follow **cliptude-script** (web search → spoken narration → `--script-file`), or ask Cliptude to write it with `cliptude script`. After a completed `script` or `voiceover` job, `cliptude continue <job-id>` turns that same job into a full video (reuses the script; voiceover jobs reuse the TTS file). `--voiceover` is a local audio file (same as create.html); it is transcribed and skips TTS — do not combine it with prompt/script. `--talking-head` is a presenter video on a Talking Head template (MP4, MOV, WEBM, AVI); it is transcribed and skips TTS. Optional `--duration` is a wizard bucket (`3-4`, `6-8`, `10-12`, …). Omit it to use the template duration, or the word-count estimate when you pass `--script`. Uploaded audio or talking-head video sets duration from the file. Avatar Video templates can override **Avatar Intro Only** and **AI Image + AI Video** with `--avatar-intro-only` / `--no-avatar-intro-only` and `--avatar-ai-footage` / `--no-avatar-ai-footage`. Omit those flags to keep the template. `generate` / `script` / `voiceover` / `continue` return immediately (`queued`). Poll `status`.
|
|
75
93
|
|
|
76
94
|
## MCP
|
package/cliptude_mcp/cli.py
CHANGED
|
@@ -143,6 +143,15 @@ def _run_auth(auth_cmd: str) -> None:
|
|
|
143
143
|
print(f"Logged in{f' as {email}' if email else '.'}")
|
|
144
144
|
|
|
145
145
|
|
|
146
|
+
def _review_arg(value: str) -> dict:
|
|
147
|
+
"""--review "quote|author|rating" -> {quote, author, rating}."""
|
|
148
|
+
parts = [p.strip() for p in value.split("|")]
|
|
149
|
+
review = {"quote": parts[0], "author": parts[1] if len(parts) > 1 else ""}
|
|
150
|
+
if len(parts) > 2 and parts[2]:
|
|
151
|
+
review["rating"] = float(parts[2])
|
|
152
|
+
return review
|
|
153
|
+
|
|
154
|
+
|
|
146
155
|
def main(argv: list[str] | None = None) -> None:
|
|
147
156
|
parser = argparse.ArgumentParser(
|
|
148
157
|
prog="cliptude",
|
|
@@ -395,6 +404,38 @@ def main(argv: list[str] | None = None) -> None:
|
|
|
395
404
|
)
|
|
396
405
|
cont.add_argument("job_id")
|
|
397
406
|
|
|
407
|
+
prod = sub.add_parser(
|
|
408
|
+
"product",
|
|
409
|
+
help="Product videos from a store: fetch a product, draft its 80/20 script, render, check status",
|
|
410
|
+
formatter_class=argparse.RawDescriptionHelpFormatter,
|
|
411
|
+
epilog=(
|
|
412
|
+
"examples:\n"
|
|
413
|
+
" cliptude product fetch https://store.com/products/handle\n"
|
|
414
|
+
" cliptude product script <product-id> --angle 1 --duration 10-12 --discount-code YOUTUBE15\n"
|
|
415
|
+
" cliptude product render <job-id> --aspect-ratio 16:9\n"
|
|
416
|
+
" cliptude product status <job-id>"
|
|
417
|
+
),
|
|
418
|
+
)
|
|
419
|
+
prod_sub = prod.add_subparsers(dest="product_cmd", required=True)
|
|
420
|
+
pf = prod_sub.add_parser("fetch", help="Read a product URL (or search a store) and get 3 video angles")
|
|
421
|
+
pf.add_argument("url_or_query")
|
|
422
|
+
pf.add_argument("--store", default="", help="Store domain to search, e.g. acme.com")
|
|
423
|
+
ps = prod_sub.add_parser("script", help="Queue the 80/20 educational script for a product")
|
|
424
|
+
ps.add_argument("product_id")
|
|
425
|
+
ps.add_argument("--angle", default="0", help="Angle index 0-2, or a custom educational title")
|
|
426
|
+
ps.add_argument("--duration", default="6-8", help="6-8, 10-12, 18-20, 30-40, 50-60 or minutes (6-60)")
|
|
427
|
+
ps.add_argument("--template", default="", help="Faceless Documentary template id")
|
|
428
|
+
ps.add_argument("--title", default="")
|
|
429
|
+
ps.add_argument("--discount-code", default="")
|
|
430
|
+
ps.add_argument("--cta-url", default="")
|
|
431
|
+
ps.add_argument("--review", action="append", default=[],
|
|
432
|
+
help='A real customer review, "quote|author|rating" (repeat up to 3 times)')
|
|
433
|
+
pr = prod_sub.add_parser("render", help="Produce the video from a ready product script")
|
|
434
|
+
pr.add_argument("job_id")
|
|
435
|
+
pr.add_argument("--aspect-ratio", default="16:9")
|
|
436
|
+
pst = prod_sub.add_parser("status", help="Stage, script, preview link and MP4 of a product video")
|
|
437
|
+
pst.add_argument("job_id")
|
|
438
|
+
|
|
398
439
|
pj = sub.add_parser(
|
|
399
440
|
"plan-job",
|
|
400
441
|
help="Start an agent-planned job: Cliptude voices the narration and stops at plan_ready",
|
|
@@ -484,6 +525,8 @@ def main(argv: list[str] | None = None) -> None:
|
|
|
484
525
|
rn = sub.add_parser("render", help="Render an edited project to a new MP4")
|
|
485
526
|
rn.add_argument("project_id")
|
|
486
527
|
rn.add_argument("--wait", action="store_true", help="Poll until the render finishes")
|
|
528
|
+
rn.add_argument("--accept-quality-findings", action="store_true",
|
|
529
|
+
help="Agent-planned jobs: render although plan-review still lists plan quality findings")
|
|
487
530
|
|
|
488
531
|
rs = sub.add_parser("render-status", help="Get an editor render (output_url when done)")
|
|
489
532
|
rs.add_argument("render_id")
|
|
@@ -682,6 +725,20 @@ def main(argv: list[str] | None = None) -> None:
|
|
|
682
725
|
_print({"ok": True, "path": str(dest.resolve())})
|
|
683
726
|
elif args.cmd == "continue":
|
|
684
727
|
_print(client.continue_job(args.job_id))
|
|
728
|
+
elif args.cmd == "product":
|
|
729
|
+
if args.product_cmd == "fetch":
|
|
730
|
+
_print(client.fetch_product_context(args.url_or_query, store_domain=args.store or None))
|
|
731
|
+
elif args.product_cmd == "script":
|
|
732
|
+
angle = int(args.angle) if str(args.angle).isdigit() else args.angle
|
|
733
|
+
_print(client.draft_product_script(
|
|
734
|
+
args.product_id, angle=angle, duration=args.duration, template_id=args.template or None,
|
|
735
|
+
title=args.title or None, discount_code=args.discount_code or None, cta_url=args.cta_url or None,
|
|
736
|
+
reviews=[_review_arg(r) for r in args.review] or None,
|
|
737
|
+
))
|
|
738
|
+
elif args.product_cmd == "render":
|
|
739
|
+
_print(client.render_product_video(args.job_id, aspect_ratio=args.aspect_ratio))
|
|
740
|
+
else:
|
|
741
|
+
_print(client.get_product_video_status(args.job_id))
|
|
685
742
|
elif args.cmd == "editor":
|
|
686
743
|
_print(client.open_editor_project(args.job_id))
|
|
687
744
|
elif args.cmd == "agent":
|
|
@@ -705,7 +762,7 @@ def main(argv: list[str] | None = None) -> None:
|
|
|
705
762
|
elif args.cmd == "agent-tiers":
|
|
706
763
|
_print(client.agent_tiers())
|
|
707
764
|
elif args.cmd == "render":
|
|
708
|
-
payload = client.render_project(args.project_id)
|
|
765
|
+
payload = client.render_project(args.project_id, accept_quality_findings=args.accept_quality_findings)
|
|
709
766
|
if args.wait:
|
|
710
767
|
render_id = (payload.get("render") or {}).get("id")
|
|
711
768
|
payload = _wait(lambda: client.get_render(render_id), lambda p: (p.get("render") or {}).get("status"))
|
package/cliptude_mcp/client.py
CHANGED
|
@@ -651,6 +651,47 @@ class CliptudeClient:
|
|
|
651
651
|
"""Queue a completed script/voiceover job, or a plan job with a locked plan, as a full video."""
|
|
652
652
|
return self.request("POST", f"/api/v1/jobs/{job_id}/continue")
|
|
653
653
|
|
|
654
|
+
# Product videos (store products: Shopify, any store page) --------------------------------------
|
|
655
|
+
|
|
656
|
+
def fetch_product_context(self, product_url_or_query: str, *, store_domain: str | None = None) -> Any:
|
|
657
|
+
"""Read a store product (URL, connected-store id/handle, or a search on store_domain) and get 3 angles."""
|
|
658
|
+
body: dict[str, Any] = {"url_or_query": product_url_or_query}
|
|
659
|
+
if store_domain:
|
|
660
|
+
body["store_domain"] = store_domain
|
|
661
|
+
return self.request("POST", "/api/v1/commerce/products/fetch", json_body=body)
|
|
662
|
+
|
|
663
|
+
def draft_product_script(
|
|
664
|
+
self,
|
|
665
|
+
product_id: str,
|
|
666
|
+
*,
|
|
667
|
+
angle: Any = None,
|
|
668
|
+
duration: str | int | None = None,
|
|
669
|
+
template_id: str | None = None,
|
|
670
|
+
title: str | None = None,
|
|
671
|
+
discount_code: str | None = None,
|
|
672
|
+
cta_url: str | None = None,
|
|
673
|
+
cta_text: str | None = None,
|
|
674
|
+
image_urls: list[str] | None = None,
|
|
675
|
+
reviews: list[dict] | None = None,
|
|
676
|
+
) -> Any:
|
|
677
|
+
"""Queue the 80/20 educational script for a product; returns {script_id, ...} immediately."""
|
|
678
|
+
body: dict[str, Any] = {"product_id": product_id}
|
|
679
|
+
for key, value in (
|
|
680
|
+
("angle", angle), ("duration", duration), ("template_id", template_id), ("title", title),
|
|
681
|
+
("discount_code", discount_code), ("cta_url", cta_url), ("cta_text", cta_text),
|
|
682
|
+
("image_urls", image_urls), ("reviews", reviews),
|
|
683
|
+
):
|
|
684
|
+
if value not in (None, "", []):
|
|
685
|
+
body[key] = value
|
|
686
|
+
return self.request("POST", "/api/v1/commerce/scripts", json_body=body)
|
|
687
|
+
|
|
688
|
+
def render_product_video(self, job_id: str, *, aspect_ratio: str = "16:9") -> Any:
|
|
689
|
+
"""Turn a ready product script into the video on the same job id (returns immediately)."""
|
|
690
|
+
return self.request("POST", f"/api/v1/commerce/videos/{job_id}/render", json_body={"aspect_ratio": aspect_ratio})
|
|
691
|
+
|
|
692
|
+
def get_product_video_status(self, job_id: str) -> Any:
|
|
693
|
+
return self.request("GET", f"/api/v1/commerce/videos/{job_id}")
|
|
694
|
+
|
|
654
695
|
# Agent-planned videos -------------------------------------------------------------------------
|
|
655
696
|
|
|
656
697
|
def upload_plan_media(self, job_id: str, path: str | Path) -> Any:
|
|
@@ -819,6 +860,13 @@ class CliptudeClient:
|
|
|
819
860
|
params = {"design": "1"} if design else None
|
|
820
861
|
return self.request("GET", f"/api/v1/editor-projects/{project_id}", params=params)
|
|
821
862
|
|
|
863
|
+
def view_scenes(self, project_id: int | str, *, start_s: float = 0.0, end_s: float | None = None) -> Any:
|
|
864
|
+
"""Contact sheets (base64 JPEG) of the timeline's pictures, clip frames and graphics, with a legend."""
|
|
865
|
+
params: dict[str, Any] = {"start_s": start_s}
|
|
866
|
+
if end_s is not None:
|
|
867
|
+
params["end_s"] = end_s
|
|
868
|
+
return self.request("GET", f"/api/v1/editor-projects/{project_id}/scenes", params=params)
|
|
869
|
+
|
|
822
870
|
def agent_tiers(self) -> Any:
|
|
823
871
|
return self.request("GET", "/api/v1/agent/tiers")
|
|
824
872
|
|
|
@@ -856,9 +904,10 @@ class CliptudeClient:
|
|
|
856
904
|
def cancel_agent_run(self, project_id: int | str, run_id: str) -> Any:
|
|
857
905
|
return self.request("POST", f"/api/v1/editor-projects/{project_id}/agent/runs/{run_id}/cancel")
|
|
858
906
|
|
|
859
|
-
def render_project(self, project_id: int | str) -> Any:
|
|
907
|
+
def render_project(self, project_id: int | str, *, accept_quality_findings: bool = False) -> Any:
|
|
860
908
|
"""Render the edited timeline to a new MP4: free the first time, then 10% of the original generation."""
|
|
861
|
-
|
|
909
|
+
body = {"accept_quality_findings": True} if accept_quality_findings else None
|
|
910
|
+
return self.request("POST", f"/api/v1/editor-projects/{project_id}/render", json_body=body)
|
|
862
911
|
|
|
863
912
|
def get_render(self, render_id: int | str) -> Any:
|
|
864
913
|
return self.request("GET", f"/api/v1/editor-renders/{render_id}")
|
package/cliptude_mcp/server.py
CHANGED
|
@@ -2,11 +2,14 @@
|
|
|
2
2
|
|
|
3
3
|
from __future__ import annotations
|
|
4
4
|
|
|
5
|
+
import base64
|
|
6
|
+
import json
|
|
5
7
|
import logging
|
|
6
8
|
import os
|
|
7
9
|
import sys
|
|
8
10
|
from typing import Annotated, Any
|
|
9
11
|
|
|
12
|
+
from mcp.server.mcpserver import Image
|
|
10
13
|
from pydantic import Field
|
|
11
14
|
|
|
12
15
|
from cliptude_mcp.client import CliptudeApiError, CliptudeClient, set_request_token
|
|
@@ -126,7 +129,15 @@ def build_server(*, with_http_auth: bool = False):
|
|
|
126
129
|
"and Cliptude only voices, sources and renders. create_plan_job, poll get_job until "
|
|
127
130
|
"plan_ready, get_narration (numbered sentences), get_kind_catalog (compact first), write the "
|
|
128
131
|
"plan, check_plan until valid, lock_plan, continue_job, then get_plan_report. See the "
|
|
129
|
-
"cliptude-plan skill."
|
|
132
|
+
"cliptude-plan skill. "
|
|
133
|
+
"PRODUCT VIDEOS (the user's connected store, or a product page from a store they sell for): "
|
|
134
|
+
"fetch_product_context, show the user the 3 angles, draft_product_script with their pick and a "
|
|
135
|
+
"duration (6-8 to 50-60 minutes), poll get_product_video_status until script_ready, let the user "
|
|
136
|
+
"review the script, render_product_video (this starts the build, not the final MP4), poll until "
|
|
137
|
+
"ready_for_review, open_editor_project and look at every picture and graphic yourself with "
|
|
138
|
+
"view_scenes (contact sheets; media links may not open for you), give the user editor_url, and only after they approve render with "
|
|
139
|
+
"render_project + get_render. "
|
|
140
|
+
"Never publish anything to a store or YouTube without the user's explicit go-ahead."
|
|
130
141
|
),
|
|
131
142
|
}
|
|
132
143
|
if with_http_auth:
|
|
@@ -571,6 +582,87 @@ def build_server(*, with_http_auth: bool = False):
|
|
|
571
582
|
except Exception as exc:
|
|
572
583
|
return _err(exc)
|
|
573
584
|
|
|
585
|
+
@mcp.tool(
|
|
586
|
+
title="Fetch product context",
|
|
587
|
+
annotations=ToolAnnotations(title="Fetch product context", read_only_hint=True, destructive_hint=False,
|
|
588
|
+
open_world_hint=True),
|
|
589
|
+
)
|
|
590
|
+
def fetch_product_context(
|
|
591
|
+
product_url_or_query: Annotated[str, Field(min_length=1, description=(
|
|
592
|
+
"A product page URL from the user's own store (Shopify, e.g. https://store.com/products/handle; "
|
|
593
|
+
"WooCommerce or Etsy work through the page's structured data), a connected store's "
|
|
594
|
+
"product id/handle, or a search term together with store_domain."))],
|
|
595
|
+
store_domain: Annotated[str | None, Field(description=(
|
|
596
|
+
"Store to search or read from, e.g. acme.com or acme.myshopify.com. Uses the user's connected "
|
|
597
|
+
"store when it matches."))] = None,
|
|
598
|
+
) -> dict[str, Any]:
|
|
599
|
+
"""Read a store product: title, price, variants, description and its real image URLs, saved as product_id, plus 3 educational YouTube video angles (80% teaching, 20% product). A search that matches several products returns candidates; fetch again with the chosen URL. Show the user the angles before drafting."""
|
|
600
|
+
try:
|
|
601
|
+
return _client().fetch_product_context(product_url_or_query, store_domain=store_domain)
|
|
602
|
+
except Exception as exc:
|
|
603
|
+
return _err(exc)
|
|
604
|
+
|
|
605
|
+
@mcp.tool(
|
|
606
|
+
title="Draft product video script",
|
|
607
|
+
annotations=ToolAnnotations(title="Draft product video script", read_only_hint=False, destructive_hint=False),
|
|
608
|
+
)
|
|
609
|
+
def draft_product_script(
|
|
610
|
+
product_id: Annotated[str, Field(min_length=8, description="product_id from fetch_product_context")],
|
|
611
|
+
angle: Annotated[int | str | dict | None, Field(description=(
|
|
612
|
+
"Index (0-2) of an angle from fetch_product_context, an angle object {title, problem, hook}, or "
|
|
613
|
+
"a custom educational title. Default 0."))] = None,
|
|
614
|
+
duration: Annotated[str | int | None, Field(description=(
|
|
615
|
+
"Length: 6-8, 10-12, 18-20, 30-40 or 50-60 (minutes), or a number of minutes from 6 to 60. "
|
|
616
|
+
"Default 6-8."))] = None,
|
|
617
|
+
template_id: Annotated[str | None, Field(description=(
|
|
618
|
+
"Faceless Documentary template to use (voice, look, music). Omit to use the latest one, or a "
|
|
619
|
+
"default Product Explainer template."))] = None,
|
|
620
|
+
title: Annotated[str | None, Field(description="Video title. Defaults to the angle title.")] = None,
|
|
621
|
+
discount_code: Annotated[str | None, Field(description="Discount code the merchant gave. Never invent one.")] = None,
|
|
622
|
+
cta_url: Annotated[str | None, Field(description="Where viewers should go. Defaults to the product page.")] = None,
|
|
623
|
+
image_urls: Annotated[list[str] | None, Field(description=(
|
|
624
|
+
"Which of the product's image URLs to show (defaults to all of them)."))] = None,
|
|
625
|
+
reviews: Annotated[list[dict] | None, Field(description=(
|
|
626
|
+
"Up to 3 real customer reviews the merchant gave you, word for word: "
|
|
627
|
+
"[{quote, author, rating (1-5), verified}]. Enables the review card. Never write or "
|
|
628
|
+
"paraphrase a review."))] = None,
|
|
629
|
+
) -> dict[str, Any]:
|
|
630
|
+
"""Queue the narration for a product video: an educational documentary for about 80% of its length, then a natural bridge to the product (real specs, price, offer) in the last 20%. Returns script_id (the job id) immediately; poll get_product_video_status until stage is script_ready, then show the user the script."""
|
|
631
|
+
try:
|
|
632
|
+
return _client().draft_product_script(
|
|
633
|
+
product_id, angle=angle, duration=duration, template_id=template_id, title=title,
|
|
634
|
+
discount_code=discount_code, cta_url=cta_url, image_urls=image_urls, reviews=reviews,
|
|
635
|
+
)
|
|
636
|
+
except Exception as exc:
|
|
637
|
+
return _err(exc)
|
|
638
|
+
|
|
639
|
+
@mcp.tool(
|
|
640
|
+
title="Render product video",
|
|
641
|
+
annotations=ToolAnnotations(title="Render product video", read_only_hint=False, destructive_hint=False),
|
|
642
|
+
)
|
|
643
|
+
def render_product_video(
|
|
644
|
+
script_id: Annotated[str, Field(min_length=8, description="script_id / job_id from draft_product_script, once script_ready")],
|
|
645
|
+
aspect_ratio: Annotated[str, Field(description="16:9 (YouTube), 9:16, 1:1 or 4:5")] = "16:9",
|
|
646
|
+
) -> dict[str, Any]:
|
|
647
|
+
"""Start BUILDING the video from the approved script on the same job id: voiceover, sourcing, motion graphics, and the merchant's real product photos composited into the closing product boards. This does not render the final MP4: when the build is done (ready_for_review) review it, show the user the editor_url and wait for their go-ahead before render_project. Returns {job_id, status, stage, editor_url, estimated_minutes} immediately; never wait in this call. Poll get_product_video_status."""
|
|
648
|
+
try:
|
|
649
|
+
return _client().render_product_video(script_id, aspect_ratio=aspect_ratio)
|
|
650
|
+
except Exception as exc:
|
|
651
|
+
return _err(exc)
|
|
652
|
+
|
|
653
|
+
@mcp.tool(
|
|
654
|
+
title="Get product video status",
|
|
655
|
+
annotations=ToolAnnotations(title="Get product video status", read_only_hint=True, destructive_hint=False),
|
|
656
|
+
)
|
|
657
|
+
def get_product_video_status(
|
|
658
|
+
job_id: Annotated[str, Field(min_length=8, description="Job id from draft_product_script / render_product_video")],
|
|
659
|
+
) -> dict[str, Any]:
|
|
660
|
+
"""Stage of a product video (script_drafting, script_ready, producing, ready_for_review, rendered, failed) with the script once written, the editor_url to preview, the MP4 URL once rendered, and next_step telling you what to do."""
|
|
661
|
+
try:
|
|
662
|
+
return _client().get_product_video_status(job_id)
|
|
663
|
+
except Exception as exc:
|
|
664
|
+
return _err(exc)
|
|
665
|
+
|
|
574
666
|
@mcp.tool(
|
|
575
667
|
title="Create agent-planned job",
|
|
576
668
|
annotations=ToolAnnotations(title="Create agent-planned job", read_only_hint=False, destructive_hint=False),
|
|
@@ -721,7 +813,7 @@ def build_server(*, with_http_auth: bool = False):
|
|
|
721
813
|
def get_plan_review(
|
|
722
814
|
job_id: Annotated[str, Field(min_length=8, description="Plan job UUID (status ready_for_edit)")],
|
|
723
815
|
) -> dict[str, Any]:
|
|
724
|
-
"""What the built design shows, before any render: every picture/clip in order (beat, time, the sentence under it, what you asked for, what was used, a link to the file) and every graphic (time on screen and the props it will be drawn with, or why it is missing).
|
|
816
|
+
"""What the built design shows, before any render: every picture/clip in order (beat, time, the sentence under it, what you asked for, what was used, a link to the file) and every graphic (time on screen and the props it will be drawn with, or why it is missing), plus quality_findings: Cliptude's quality checks on the build. Fix every finding with fix_in "plan" (follow its how); fix_in "cliptude" ones are not yours. Revise with check_plan/lock_plan + continue_job on the same job, review again, then render_project once (it refuses while plan findings remain unless accept_quality_findings is true)."""
|
|
725
817
|
try:
|
|
726
818
|
return _client().get_plan_review(job_id)
|
|
727
819
|
except Exception as exc:
|
|
@@ -903,6 +995,26 @@ def build_server(*, with_http_auth: bool = False):
|
|
|
903
995
|
except Exception as exc:
|
|
904
996
|
return _err(exc)
|
|
905
997
|
|
|
998
|
+
@mcp.tool(
|
|
999
|
+
title="View scenes",
|
|
1000
|
+
annotations=ToolAnnotations(title="View scenes", read_only_hint=True, open_world_hint=False),
|
|
1001
|
+
)
|
|
1002
|
+
def view_scenes(
|
|
1003
|
+
project_id: Annotated[int, Field(description="Editor project id")],
|
|
1004
|
+
start_s: Annotated[float, Field(ge=0, description="First second to show")] = 0.0,
|
|
1005
|
+
end_s: Annotated[float | None, Field(description="Stop before this second (default: the end)")] = None,
|
|
1006
|
+
) -> list[str | Image]:
|
|
1007
|
+
"""See what the timeline shows, without opening any link: numbered contact sheets of every picture, a frame of every clip and each graphic's picture with its words, with the narration under each, plus a legend (tile, item_id, start_s, end_s, words, said, flags). Up to 24 tiles per call; call again from next_start_s. Use it to review a built video yourself (other brands, wrong pictures, repeats, leftover text) before giving the user the editor link, and again after run_agent to check the change."""
|
|
1008
|
+
try:
|
|
1009
|
+
data = _client().view_scenes(project_id, start_s=start_s, end_s=end_s)
|
|
1010
|
+
except Exception as exc:
|
|
1011
|
+
return [json.dumps(_err(exc))]
|
|
1012
|
+
sheets = data.pop("sheets", None) or []
|
|
1013
|
+
out: list[str | Image] = [json.dumps(data, ensure_ascii=False)]
|
|
1014
|
+
for sheet in sheets:
|
|
1015
|
+
out.append(Image(data=base64.b64decode(sheet["jpeg_base64"]), format="jpeg"))
|
|
1016
|
+
return out
|
|
1017
|
+
|
|
906
1018
|
@mcp.tool(
|
|
907
1019
|
title="Run Cliptude Agent",
|
|
908
1020
|
annotations=ToolAnnotations(title="Run Cliptude Agent", read_only_hint=False, destructive_hint=False),
|
|
@@ -916,7 +1028,7 @@ def build_server(*, with_http_auth: bool = False):
|
|
|
916
1028
|
tier: Annotated[str, Field(description="fast or smart")] = "fast",
|
|
917
1029
|
chat_id: Annotated[str | None, Field(description="Continue an existing agent chat")] = None,
|
|
918
1030
|
) -> dict[str, Any]:
|
|
919
|
-
"""Ask Cliptude Agent to edit the timeline (swap footage, regenerate images or voiceover ranges, music, transitions, text). Returns a run; poll get_agent_run. Charges agent credits. Then render_project for a new MP4."""
|
|
1031
|
+
"""Ask Cliptude Agent to edit the timeline (swap footage, regenerate images or voiceover ranges, music, transitions, text). One kind of change per run: picture swaps and text edits go in separate runs. Several clips can get new pictures in one run: reference them all and describe each one's picture by its item id; a clip with nothing suitable is left unchanged and named in the reply. Swapping a graphic's picture keeps the graphic and its words. Returns a run; poll get_agent_run. Charges agent credits. Then render_project for a new MP4, after view_scenes on the changed range."""
|
|
920
1032
|
try:
|
|
921
1033
|
return _client().run_agent(
|
|
922
1034
|
project_id, prompt=prompt, tier=tier, referenced_item_ids=referenced_item_ids, chat_id=chat_id
|
|
@@ -958,10 +1070,14 @@ def build_server(*, with_http_auth: bool = False):
|
|
|
958
1070
|
)
|
|
959
1071
|
def render_project(
|
|
960
1072
|
project_id: Annotated[int, Field(description="Editor project id")],
|
|
1073
|
+
accept_quality_findings: Annotated[
|
|
1074
|
+
bool,
|
|
1075
|
+
Field(description="Agent-planned jobs only: render although get_plan_review still lists quality_findings with fix_in \"plan\". Set it only after trying to fix them, or when the user says to ship as is."),
|
|
1076
|
+
] = False,
|
|
961
1077
|
) -> dict[str, Any]:
|
|
962
|
-
"""Render the edited timeline to a new MP4. The first export of a project is free; later exports cost 10% of the original generation (export_credits_due on the project says the exact amount). Poll get_render for output_url."""
|
|
1078
|
+
"""Render the edited timeline to a new MP4. The first export of a project is free; later exports cost 10% of the original generation (export_credits_due on the project says the exact amount). Poll get_render for output_url. On an agent-planned job, a build with quality_findings the plan can fix returns 409 quality_findings_open: revise the plan and review again first."""
|
|
963
1079
|
try:
|
|
964
|
-
return _client().render_project(project_id)
|
|
1080
|
+
return _client().render_project(project_id, accept_quality_findings=accept_quality_findings)
|
|
965
1081
|
except Exception as exc:
|
|
966
1082
|
return _err(exc)
|
|
967
1083
|
|
package/package.json
CHANGED
package/pyproject.toml
CHANGED