add local project build tool

Dockerfile

@@ -1,17 +1,40 @@
 FROM python:3.10-slim
 
+# Install Node to run Motion Canvas
+WORKDIR /tmp/node
+RUN apt-get update && apt-get install -y nodejs npm
+
+
+# without v prefix!
+ARG MC_VERSION="3.17.2" 
+ENV NODE_ENV=$MC_VERSION
+
+WORKDIR /motion-canvas
+
+RUN yes '' | npm init -y @motion-canvas@$MC_VERSION
+
+WORKDIR /motion-canvas/my-animation
+ENV MC_PROJECT_DIR=/motion-canvas/my-animation
+
+# copy the vite.config.ts file to the project to get deterministic output filenames under dist/project.js
+COPY docker/vite.config.ts ./vite.config.ts
+
+# if we build here, we have to clean up the project every time before building a new one...
+RUN npm install
+RUN npm run build
+
+
 # Install Gradio and copy local files
 WORKDIR /app
-
-COPY requirements.txt .
+COPY ./requirements.txt .
 RUN pip install --no-cache-dir -r requirements.txt
-
 COPY . .
 
 RUN mkdir -p /app/public
 
 RUN useradd -m -u 1000 user
 
+RUN chown -R user:user /motion-canvas
 RUN chown -R user:user /app
 USER user
 

app.py

@@ -8,40 +8,122 @@ from threading import Timer
 from functools import partial
 import time
 
-from huggingface_hub import InferenceClient
-from smolagents import ToolCollection, CodeAgent, InferenceClientModel
+from smolagents import ToolCollection, ToolCallingAgent, InferenceClientModel, EMPTY_PROMPT_TEMPLATES
 
-MODEL = "Qwen/Qwen2.5-Coder-32B-Instruct"
+MODEL = "meta-llama/Llama-3.3-70B-Instruct"
 
-BUILD_SERVER_MCP_CONFIG = {"url": "https://agents-mcp-hackathon-gradio-motioncanvas-mcp-server.hf.space/gradio_api/mcp/sse", "transport": "sse"}
+BUILD_SERVER_MCP_CONFIG = {"url": "https://prathje-gradio-motioncanvas-mcp-server.hf.space/gradio_api/mcp/sse", "transport": "sse"}
 DOCS_SERVER_MCP_CONFIG = {"url": "https://prathje-gradio-motioncanvas-docs-mcp-server.hf.space/gradio_api/mcp/sse", "transport": "sse"}
 
-all_tools = []
-with ToolCollection.from_mcp(BUILD_SERVER_MCP_CONFIG, trust_remote_code=True) as build_tool_collection:
-    with ToolCollection.from_mcp(DOCS_SERVER_MCP_CONFIG, trust_remote_code=True) as docs_tool_collection:
-        all_tools = build_tool_collection.tools + docs_tool_collection.tools
+SYSTEM_PROMPT = "You are a helpful assistant that generates motion canvas scenes. The user prompts his ideas. You should use the recursive_list to check for available classes and examples. You should generate the code for a single standalone motion canvas scene.tsx and build it using the build tool. If the build response is empty, it means the build failed and the code is not valid. You can use all tools provided to you to help you with your task."
+
+from smolagents import tool
+
+
+
+gr.set_static_paths(paths=[os.path.join(os.path.dirname(__file__), "public")])
+
+def get_local_path(project_id):
+    return os.path.join(os.path.dirname(__file__), "public", "project-" + project_id + ".js")
+
+def get_public_path(project_id):
+    return "/gradio_api/file=" + get_local_path(project_id)
 
-if os.environ.get("HF_TOKEN"):
+BUILD_TIMEOUT=30
+
+# In theory, we should be using the build server mcp, but it not working right now and we are running out of time ;)
+@tool
+def build_project(code: str) -> str:
+    """Build a Motion Canvas project.
     
-    model = InferenceClientModel(model_id=MODEL)
-
-    agent = CodeAgent(tools=[*all_tools], model=model)
-
-    def generate(message, history, code, logs):
-        try:
-            res = agent.run(
-                "From the following prompt, generate code for a standalone motion canvas scene.tsx and build. You can browse the docs to help you.",
-                additional_args={'prompt': 'Please animate the formula for the area of a circle'}
-            )
-            print(res)
-        except Exception as e:
-            print(e)
-            return "An error occurred while generating the code", "", ""
-else:
-    print("No HF_TOKEN found, Zero GPU space not implemented")
-    def generate(message, history, code, logs):
-        return "LLM not available", "", ""
+    Args:
+        code: TypeScript code for the scene to build
+    """
+
+    # generate a random uuid for the project
+    project_id = str(uuid.uuid4())
+
+    tmp_dir = os.path.join("/tmp/", project_id)
 
+    shutil.copytree(os.environ['MC_PROJECT_DIR'], tmp_dir, dirs_exist_ok=False, symlinks=True)
+    acc_logs = ""
+    
+    try:
+
+        # write code to scene.ts
+        with open(os.path.join(tmp_dir, "src", "scenes",  "example.tsx"), "w") as f:
+            f.write(code)
+
+        process = subprocess.Popen(
+            "npm run build",
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+            shell=True,
+            cwd=tmp_dir
+        )
+
+        timer = Timer(BUILD_TIMEOUT, process.kill)
+        timer.start()
+        
+        while True:
+            line = process.stdout.readline()
+            if line:
+                acc_logs += line.rstrip() + "\n"
+            elif process.poll() is not None:
+                break
+        timer.cancel()
+        
+        # Check for errors
+        stderr_output = process.stderr.read()
+        if stderr_output:
+            acc_logs += "\n" + stderr_output
+            
+        # check if the build was successful
+        if process.returncode != 0:
+            return "build failed", acc_logs
+        else:
+            # copy dist/project.js to get_local_path(id)
+            shutil.copy(os.path.join(tmp_dir, "dist", "project.js"), get_local_path(project_id))
+            return get_public_path(project_id), acc_logs       
+
+    except Exception as e:
+        return "build failed", acc_logs + "\n" + "Error building project: " + str(e)
+        
+    finally:
+         # cleanup tmp dir
+        shutil.rmtree(tmp_dir)
+
+all_tools = []
+with ToolCollection.from_mcp(BUILD_SERVER_MCP_CONFIG, trust_remote_code=True) as build_tool_collection:
+    with ToolCollection.from_mcp(DOCS_SERVER_MCP_CONFIG, trust_remote_code=True) as docs_tool_collection:
+        all_tools = docs_tool_collection.tools + [build_project]
+
+        if os.environ.get("HF_TOKEN"):
+            model = InferenceClientModel(model_id=MODEL)
+
+            agent = ToolCallingAgent(tools=[*all_tools], model=model, return_full_result=True)
+
+            agent.prompt_templates["system_prompt"] = SYSTEM_PROMPT
+
+            def generate(message, history, code, logs):
+                try:
+                    res = agent.run(
+                        "From the following prompt, generate code for a single standalone motion canvas scene.tsx and build. You can browse the docs to help you.",
+                        additional_args={'prompt': 'Please animate the formula for the area of a circle'}
+                    )
+                    print(res.messages)
+                    print(res.output)
+                except Exception as e:
+                    print(e)
+                    return "An error occurred while generating the code", "", ""
+        else:
+            print("No HF_TOKEN found, Zero GPU space not implemented")
+            def generate(message, history, code, logs):
+                return "LLM not available", "", ""
+
+        generate("test", [], "", "")
+        exit()
 
 
 from gradio_motioncanvasplayer import MotionCanvasPlayer

gradio_mcp_server.py

@@ -1,114 +0,0 @@
-from mcp.server.fastmcp import FastMCP
-import json
-import sys
-import io
-import time
-from gradio_client import Client
-
-
-
-sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding='utf-8', errors='replace')
-sys.stderr = io.TextIOWrapper(sys.stderr.buffer, encoding='utf-8', errors='replace')
-
-mcp = FastMCP("Gradio MCP Server")
-
-clients = {}
-
-
-
-def get_client(space_id: str) -> Client:
-    """Get or create a Gradio client for the specified space."""
-    if space_id not in clients:
-        clients[space_id] = Client(space_id)
-    return clients[space_id]
-
-@mcp.tool()
-async def build_project(code: str) -> str:
-    """Build a Motion Canvas project using the Gradio Motion MCP server.
-    
-    Args:
-        code: TypeScript code for the scene to build
-    """
-
-    try:
-        result = get_client(BUILD_SERVER_SPACE_ID).predict(
-            code,
-            api_name="/build"
-        )
-        
-        if isinstance(result, list) and len(result) >= 2:
-            project_path = result[0]
-            logs = result[1]
-
-            if project_path:
-                return json.dumps({
-                    "type": "mc_project",
-                    "project_path": project_path,
-                    "message": f"Built project at {project_path}",
-                    "logs": result[1]
-                })
-            else:
-                return json.dumps({
-                    "type": "error",
-                    "message": f"Error building project:\n" + logs
-                })
-        else:
-            return json.dumps({
-                "type": "error",
-                "message": f"Error building project"
-            })
-
-    except Exception as e:
-        return json.dumps({
-            "type": "error",
-            "message": f"Error building project: {str(e)}"
-        })
-
-@mcp.tool()
-async def build_project(code: str) -> str:
-    """Build a Motion Canvas project using the Gradio Motion MCP server.
-    
-    Args:
-        code: TypeScript code for the scene to build
-    """
-    client = Client("https://agents-mcp-hackathon-gradio-motioncanvas-mcp-server.hf.space/")
-
-
-
-
-    try:
-        result = client.predict(
-            code,
-            api_name="/build"
-        )
-        
-        if isinstance(result, list) and len(result) >= 2:
-            project_path = result[0]
-            logs = result[1]
-
-            if project_path:
-                return json.dumps({
-                    "type": "mc_project",
-                    "project_path": project_path,
-                    "message": f"Built project at {project_path}",
-                    "logs": result[1]
-                })
-            else:
-                return json.dumps({
-                    "type": "error",
-                    "message": f"Error building project:\n" + logs
-                })
-        else:
-            return json.dumps({
-                "type": "error",
-                "message": f"Error building project"
-            })
-
-    except Exception as e:
-        return json.dumps({
-            "type": "error",
-            "message": f"Error building project: {str(e)}"
-        })
-
-if __name__ == "__main__":
-    mcp.run(transport='stdio')

requirements.txt

@@ -1,4 +1,4 @@
 gradio[mcp]
 gradio_motioncanvasplayer
 huggingface_hub
-smolagents[mcp]
+smolagents[mcp]==1.18.0