Upload 5 files

CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## v5.2
+
+- Fix Phase 5 generated Space runtime dependency conflict by pinning `huggingface_hub>=0.34.0,<1.0.0` in target Space `requirements.txt`.
+- Add a Pi instruction not to remove the `huggingface_hub` compatibility pin.
+
+
 ## V5
 
 - Added Phase 5: `model_id` → model metadata analysis → Pi-adapted Gradio template → private Space → live API validation.
@@ -34,3 +40,25 @@
 - Added a new `pi_gist_recipe` worker payload.
 - The wrapper still performs independent final validation through the live Gradio API before declaring success.
 - Saved artifacts include `generated/GOAL.md`, optional `generated/PI_SUMMARY.md`, Pi logs, traces, API schema, and API test result.
+
+
+## v5.1
+
+- Fixed Phase 5 Pi invocation for Pi 0.73.x: use `pi -p` instead of removed `--prompt`.
+- No architecture changes; Phase 5 remains wrapper-owned for Hub operations and live API validation.
+
+
+## V6
+
+- Added Phase 6 Runtime Recommender.
+- Adds a no-build HF Job that analyzes model metadata, estimated file sizes, task/library, risks, and recommends CPU Basic / CPU Upgrade / ZeroGPU candidate / manual review.
+- Writes `model_analysis.json`, `runtime_recommendation.json`, `state.json`, `events.jsonl`, and `report.md` to the Bucket.
+
+## V7 — LongCat article reproduction pass
+
+- Added Phase 7: LongCat article-style reproduction workflow.
+- Adds a dedicated HF Job worker that asks Pi to adapt a LongCat Space scaffold using the HF Spaces gist.
+- Creates the target Space privately.
+- Requests `zero-a10g` first, with optional fixed GPU fallback (`l40sx1` by default).
+- Validates a cheap `/health` endpoint live via `gradio_client` before marking success.
+- Stores hardware attempts, model analysis, generated files, Pi logs, traces, and report in the bucket.

README.md

@@ -140,3 +140,13 @@ Phase 4 asks Pi to follow the HF Spaces Agent Quickstart gist and use the `hf` C
 ## V5
 
 Adds Phase 5: model-card analysis for simple Transformers text pipeline models. Recommended first test: `sshleifer/tiny-gpt2`. The Space remains private and success is still gated by wrapper-owned live API validation.
+
+
+## Phase 6
+
+Adds a no-build runtime recommender Job that analyzes model metadata and writes `runtime_recommendation.json` to the Bucket.
+
+
+## Phase 7 — LongCat article reproduction
+
+Phase 7 attempts an article-style LongCat Space build: private target Space, Pi-guided app adaptation, ZeroGPU first, fixed GPU fallback when explicitly enabled, and live `/health` API validation. Full video generation remains a manual-review step until model-specific runtime validation is complete.

app.py

@@ -14,6 +14,7 @@ from src.jobs import (
     launch_hello_job,
     launch_pi_gist_recipe_job,
     launch_pi_model_card_job,
+    launch_runtime_recommender_job,
     launch_pi_space_smoke_job,
 )
 from src.runs import make_run_id, validate_run_id
@@ -21,7 +22,7 @@ from src.security import redact
 
 
 APP_DESCRIPTION = f"""
-# Agentic Space Factory — V5 Model Card
+# Agentic Space Factory — V6 Runtime Recommender
 
 This version validates the two critical foundations:
 
@@ -31,6 +32,8 @@ Phase 2: HF OAuth → HF Job → private target Space → file upload → live G
 Phase 3: HF OAuth → HF Job → Pi modifies app.py → private target Space → live API validation → Pi traces
 Phase 4: HF OAuth → HF Job → Pi reads gist → uses hf CLI → private Space → wrapper live API validation
 Phase 5: HF OAuth → HF Job → model-card analysis → Pi adapts template → private model Space → live API validation
+Phase 6: HF OAuth → HF Job → model-card/runtime analysis → runtime/hardware recommendation → Bucket report
+Phase 7: HF OAuth → HF Job → LongCat article-style Space → ZeroGPU attempt → fixed GPU fallback → live health API validation
 ```
 
 Configured bucket: `{settings.bucket_uri}`
@@ -81,6 +84,71 @@ def propose_model_run_id() -> str:
     return make_run_id("model")
 
 
+def propose_runtime_run_id() -> str:
+    return make_run_id("runtime")
+
+
+def propose_longcat_run_id() -> str:
+    return make_run_id("longcat")
+
+
+def launch_longcat_article_job_ui(
+    requested_run_id: str,
+    model_id: str,
+    target_space_name: str,
+    pi_model: str,
+    preferred_hardware: str,
+    allow_fixed_gpu_fallback: bool,
+    fallback_hardware: str,
+    profile: gr.OAuthProfile | None,
+    oauth_token: gr.OAuthToken | None,
+) -> tuple[str, str, str, str, str, str]:
+    username = _profile_username(profile)
+    token = _token_value(oauth_token)
+    if not username or not token:
+        raise gr.Error("Please sign in with Hugging Face first. OAuth profile/token is missing.")
+
+    run_id = validate_run_id(requested_run_id or propose_longcat_run_id())
+    result = launch_longcat_article_job(
+        token=token,
+        username=username,
+        target_slug=target_space_name,
+        model_id=model_id,
+        pi_model=pi_model,
+        preferred_space_hardware=preferred_hardware,
+        fallback_space_hardware=fallback_hardware,
+        allow_fixed_gpu_fallback=allow_fixed_gpu_fallback,
+        run_id=run_id,
+    )
+    job_url = result.get("job_url") or ""
+    target_space = result.get("target_space") or ""
+    target_url = result.get("target_space_url") or ""
+    summary = json.dumps(result, indent=2)
+    return run_id, result["job_id"], job_url, target_space, target_url, summary
+
+
+def launch_runtime_recommender_job_ui(
+    requested_run_id: str,
+    model_id: str,
+    profile: gr.OAuthProfile | None,
+    oauth_token: gr.OAuthToken | None,
+) -> tuple[str, str, str, str]:
+    username = _profile_username(profile)
+    token = _token_value(oauth_token)
+    if not username or not token:
+        raise gr.Error("Please sign in with Hugging Face first. OAuth profile/token is missing.")
+
+    run_id = validate_run_id(requested_run_id or propose_runtime_run_id())
+    result = launch_runtime_recommender_job(
+        token=token,
+        username=username,
+        model_id=model_id,
+        run_id=run_id,
+    )
+    job_url = result.get("job_url") or ""
+    summary = json.dumps(result, indent=2)
+    return run_id, result["job_id"], job_url, summary
+
 
 def launch_pi_model_card_job_ui(
     requested_run_id: str,
@@ -245,6 +313,144 @@ def build_demo() -> gr.Blocks:
         demo.load(fn=get_login_status, inputs=None, outputs=login_status)
 
 
+        with gr.Tab("Phase 7 — LongCat article reproduction"):
+            gr.Markdown(
+                """
+This phase attempts to reproduce the article-style workflow for `meituan-longcat/LongCat-Video-Avatar-1.5`.
+
+It creates a **private** target Space, asks Pi to adapt a LongCat app scaffold while following the HF Spaces gist, requests `zero-a10g` first, and optionally falls back to a fixed GPU hardware if ZeroGPU is unavailable/quota-limited.
+
+Safety: the Space remains private, publication is never automatic, and the wrapper validates a cheap `/health` endpoint first. Full video generation may still require manual review and real GPU/runtime tuning.
+"""
+            )
+            with gr.Row():
+                longcat_run_id_box = gr.Textbox(label="Run ID", value=propose_longcat_run_id, interactive=True)
+                new_longcat_run_btn = gr.Button("Generate new run id")
+            new_longcat_run_btn.click(fn=propose_longcat_run_id, inputs=None, outputs=longcat_run_id_box)
+
+            longcat_model_id_box = gr.Textbox(
+                label="Model ID",
+                value="meituan-longcat/LongCat-Video-Avatar-1.5",
+                info="Default is the model from the article. You can override for controlled experiments.",
+            )
+            longcat_target_space_name = gr.Textbox(
+                label="Target Space name",
+                placeholder="e.g. space-factory-longcat-v1",
+                info="Use a fresh name. The Space is created under your username and remains private.",
+            )
+            longcat_pi_model_box = gr.Textbox(
+                label="Pi model",
+                value="moonshotai/Kimi-K2.5",
+                info="Model used by Pi through Hugging Face Inference Providers.",
+            )
+            with gr.Row():
+                longcat_preferred_hw = gr.Dropdown(
+                    label="Preferred Space hardware",
+                    choices=["zero-a10g", "l40sx1", "a10g-large", "a100-large", "h200"],
+                    value="zero-a10g",
+                    info="The worker requests this first. Use zero-a10g to try ZeroGPU.",
+                )
+                longcat_allow_fallback = gr.Checkbox(
+                    label="Allow fixed GPU fallback",
+                    value=True,
+                    info="If ZeroGPU request fails, request the fallback hardware below. This may incur billing.",
+                )
+                longcat_fallback_hw = gr.Dropdown(
+                    label="Fallback Space hardware",
+                    choices=["l40sx1", "a10g-large", "a100-large", "h200", "t4-medium"],
+                    value="l40sx1",
+                    info="Used only if preferred hardware request fails and fallback is enabled.",
+                )
+
+            launch_longcat_btn = gr.Button("Run LongCat article reproduction", variant="primary")
+            phase7_job_id_box = gr.Textbox(label="Job ID", interactive=True)
+            phase7_job_url_box = gr.Textbox(label="Job URL", interactive=False)
+            phase7_target_space_box = gr.Textbox(label="Target Space", interactive=False)
+            phase7_target_url_box = gr.Textbox(label="Target Space URL", interactive=False)
+            phase7_launch_result = gr.Code(label="Launch result", language="json")
+
+            launch_longcat_btn.click(
+                fn=launch_longcat_article_job_ui,
+                inputs=[
+                    longcat_run_id_box,
+                    longcat_model_id_box,
+                    longcat_target_space_name,
+                    longcat_pi_model_box,
+                    longcat_preferred_hw,
+                    longcat_allow_fallback,
+                    longcat_fallback_hw,
+                ],
+                outputs=[
+                    longcat_run_id_box,
+                    phase7_job_id_box,
+                    phase7_job_url_box,
+                    phase7_target_space_box,
+                    phase7_target_url_box,
+                    phase7_launch_result,
+                ],
+            )
+
+            phase7_refresh_btn = gr.Button("Refresh Phase 7 run status")
+            with gr.Tab("Phase 7 state"):
+                phase7_state = gr.Code(label="state.json", language="json")
+            with gr.Tab("Phase 7 events"):
+                phase7_events = gr.Code(label="events.jsonl", language="json")
+            with gr.Tab("Phase 7 report"):
+                phase7_report = gr.Markdown()
+            with gr.Tab("Phase 7 job"):
+                phase7_job_info = gr.Code(label="Job info/logs", language="json")
+
+            phase7_refresh_btn.click(
+                fn=refresh_run_ui,
+                inputs=[longcat_run_id_box, phase7_job_id_box],
+                outputs=[phase7_state, phase7_events, phase7_report, phase7_job_info],
+            )
+
+        with gr.Tab("Phase 6 — Runtime recommender"):
+            gr.Markdown(
+                """
+This phase does **not** create a Space. It analyzes a `model_id` and writes a runtime/hardware recommendation into the Bucket.
+
+Use it as a gate before auto-building a Space: small text models can go through Phase 5, Diffusers models become ZeroGPU candidates, and large/custom/gated models are marked for manual review.
+"""
+            )
+            with gr.Row():
+                runtime_run_id_box = gr.Textbox(label="Run ID", value=propose_runtime_run_id, interactive=True)
+                new_runtime_run_btn = gr.Button("Generate new run id")
+            new_runtime_run_btn.click(fn=propose_runtime_run_id, inputs=None, outputs=runtime_run_id_box)
+
+            runtime_model_id_box = gr.Textbox(
+                label="Model ID",
+                value="sshleifer/tiny-gpt2",
+                info="Try `sshleifer/tiny-gpt2` for CPU Basic, or a Diffusers text-to-image model to see a ZeroGPU candidate recommendation.",
+            )
+            launch_runtime_btn = gr.Button("Analyze runtime recommendation", variant="primary")
+            phase6_job_id_box = gr.Textbox(label="Job ID", interactive=False)
+            phase6_job_url_box = gr.Textbox(label="Job URL", interactive=False)
+            phase6_launch_result = gr.Code(label="Launch result", language="json")
+
+            launch_runtime_btn.click(
+                fn=launch_runtime_recommender_job_ui,
+                inputs=[runtime_run_id_box, runtime_model_id_box],
+                outputs=[runtime_run_id_box, phase6_job_id_box, phase6_job_url_box, phase6_launch_result],
+            )
+
+            phase6_refresh_btn = gr.Button("Refresh Phase 6 run status")
+            with gr.Tab("Phase 6 state"):
+                phase6_state = gr.Code(label="state.json", language="json")
+            with gr.Tab("Phase 6 events"):
+                phase6_events = gr.Code(label="events.jsonl", language="json")
+            with gr.Tab("Phase 6 report"):
+                phase6_report = gr.Markdown()
+            with gr.Tab("Phase 6 job"):
+                phase6_job_info = gr.Code(label="Job info/logs", language="json")
+
+            phase6_refresh_btn.click(
+                fn=refresh_run_ui,
+                inputs=[runtime_run_id_box, phase6_job_id_box],
+                outputs=[phase6_state, phase6_events, phase6_report, phase6_job_info],
+            )
+
         with gr.Tab("Phase 5 — Model card → private Space"):
             gr.Markdown(
                 """