synth app updated

app.py

@@ -17,7 +17,7 @@ iface = gr.Interface(
     inputs=[
         gr.Textbox(lines=20, label="Unity C# code"),
         gr.Radio(["cpp", "blueprint", "both"], value="both", label="Target"),
-        gr.Radio(["hf_inference", "openai"], value="hf_inference", label="Model backend")
+        gr.Radio(["hf", "openai"], value="hf", label="Model backend")
     ],
     outputs=[
         gr.Textbox(lines=20, label="Unreal C++ (.h/.cpp)"),

translator/agent.py

@@ -6,12 +6,14 @@ class TranslationAgent:
     def __init__(self, mapping_path="mapping_table.json"):
         self.mapping = load_mapping(mapping_path)
 
-    def translate(self, csharp_code: str, target_format="both", model_choice="hf_inference"):
+    def translate(self, csharp_code: str, target_format="both", backend="hf"):
         parsed = parse_csharp(csharp_code)
         results = {"cpp": "", "blueprint_py": ""}
+
         if target_format in ("cpp", "both"):
-            results["cpp"] = synthesize_cpp(parsed, self.mapping)
+            results["cpp"] = synthesize_cpp(parsed, self.mapping, backend=backend)
+
         if target_format in ("blueprint", "both"):
-            results["blueprint_py"] = synthesize_blueprint_python(parsed, self.mapping)
-        # return tuple for Gradio outputs
+            results["blueprint_py"] = synthesize_blueprint_python(parsed, self.mapping, backend=backend)
+
         return results["cpp"], results["blueprint_py"]

translator/examples/Rotator.cs

@@ -0,0 +1,8 @@
+using UnityEngine;
+
+public class Rotator : MonoBehaviour {
+    public float speed = 90f;
+    void Update() {
+        transform.Rotate(0, speed * Time.deltaTime, 0);
+    }
+}

translator/llm_client.py

@@ -1,28 +1,22 @@
-import os, json
 from huggingface_hub import InferenceClient
+from openai import OpenAI
+import os
 
-def generate_with_hf(prompt: str, model="gpt-4o-mini", max_new_tokens=512):
-    token = os.environ.get("HF_TOKEN") or os.environ.get("HF_TOKEN")
-    client = InferenceClient(token=token) if token else InferenceClient()  # will use unauth if possible
-    # Use chat-like API where available; else use text generation
-    response = client.text_generation(model=model, inputs=prompt, max_new_tokens=max_new_tokens)
-    # client.text_generation returns structured result; pick the text
-    if isinstance(response, list):
-        return response[0].get("generated_text", "")
-    elif isinstance(response, dict) and "generated_text" in response:
-        return response["generated_text"]
-    else:
-        # fallback stringify
-        return json.dumps(response)
+HF_MODEL_DEFAULT = "mistralai/Mixtral-8x7B-Instruct"
+OPENAI_MODEL_DEFAULT = "gpt-4o-mini"
 
-# Optional OpenAI wrapper (if user prefers)
-def generate_with_openai(prompt: str, model="gpt-4o-mini", max_tokens=512):
-    import openai
-    openai.api_key = os.environ.get("OPENAI_API_KEY")
-    resp = openai.ChatCompletion.create(
+def generate_with_hf(prompt, model=HF_MODEL_DEFAULT):
+    client = InferenceClient(model=model, token=os.getenv("HF_TOKEN"))
+    response = client.text_generation(prompt, max_new_tokens=1024)
+    return response
+
+def generate_with_openai(prompt, model=OPENAI_MODEL_DEFAULT):
+    client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
+    completion = client.chat.completions.create(
         model=model,
-        messages=[{"role":"system","content":"You are a helpful code translator."},
-                  {"role":"user","content":prompt}],
-        max_tokens=max_tokens,
+        messages=[
+            {"role": "system", "content": "You are a Unity→Unreal translation expert."},
+            {"role": "user", "content": prompt},
+        ],
     )
-    return resp["choices"][0]["message"]["content"]
+    return completion.choices[0].message.content

translator/synth.py

@@ -1,33 +1,44 @@
-def synthesize_cpp(parsed: dict, mapping: dict, prompt_context: str = "") -> str:
+from .llm_client import generate_with_hf, generate_with_openai
+
+def synthesize_cpp(parsed: dict, mapping: dict, backend: str = "hf", prompt_context: str = "") -> str:
+    """
+    Converts Unity C# parsed structure into Unreal Engine C++ (header + source).
+    """
+    prompt = f"""
+    Translate the following Unity C# class to idiomatic Unreal Engine C++ (header and source).
+    Mapping rules: {mapping}
+    Parsed structure: {parsed}
+
+    Generate two files separated with markers:
+    ---FILE: MyActor.h---
+    [contents]
+    ---FILE: MyActor.cpp---
+    [contents]
+
+    Be concise, compile-ready, and use UPROPERTY/UFUNCTION macros where suitable.
+    {prompt_context}
     """
-    Build a prompt (few-shot) + call the LLM and return generated C++ text
+
+    if backend == "hf":
+        return generate_with_hf(prompt)
+    else:
+        return generate_with_openai(prompt)
+
+def synthesize_blueprint_python(parsed: dict, mapping: dict, backend: str = "hf") -> str:
+    prompt = f"""
+    Given this parsed Unity class and mapping rules, produce a Python Editor script using Unreal's Python API
+    that will create a Blueprint Actor in /Game/Blueprints named BP_<ClassName> with:
+      - A StaticMeshComponent as root
+      - A float property 'RotationSpeed' exposed to Blueprints
+      - A Tick override that rotates actor by RotationSpeed * DeltaTime
+
+    Provide only the Python file content.
+
+    Parsed: {parsed}
+    Mapping: {mapping}
     """
-    # Build a focused prompt that includes mapping rules and parsed structure
-    prompt = f"""Translate the following Unity C# class to idiomatic Unreal Engine C++ (header and source).
-Mapping rules: {mapping}
-Parsed structure: {parsed}
-
-Generate two files separated with markers:
----FILE: MyActor.h---
-[contents]
----FILE: MyActor.cpp---
-[contents]
-
-Be concise and compile-focused. Use UPROPERTY / UFUNCTION where appropriate.
-"""
-    from .llm_client import generate_with_hf
-    return generate_with_hf(prompt, model="gpt-4o-mini")
-
-def synthesize_blueprint_python(parsed: dict, mapping: dict) -> str:
-    prompt = f"""Given this parsed Unity class and mapping rules, produce a Python Editor script (uses unreal python API)
-that will create a Blueprint Actor class in /Game/Blueprints named BP_<ClassName> with:
-  - a StaticMeshComponent as root
-  - a float property RotationSpeed exposed to Blueprints
-  - a Tick override that rotates actor by RotationSpeed * DeltaTime
-
-Provide the Python file only.
-Parsed: {parsed}
-Mapping: {mapping}
-"""
-    from .llm_client import generate_with_hf
-    return generate_with_hf(prompt, model="gpt-4o-mini")
+
+    if backend == "hf":
+        return generate_with_hf(prompt)
+    else:
+        return generate_with_openai(prompt)

translator/synth_blueprint.py

@@ -0,0 +1,20 @@
+from .llm_client import generate_with_hf, generate_with_openai
+
+def synthesize_blueprint_python(parsed: dict, mapping: dict, backend: str = "hf") -> str:
+    prompt = f"""
+    Given this parsed Unity class and mapping rules, produce a Python Editor script using Unreal's Python API
+    that will create a Blueprint Actor in /Game/Blueprints named BP_<ClassName> with:
+      - A StaticMeshComponent as root
+      - A float property 'RotationSpeed' exposed to Blueprints
+      - A Tick override that rotates actor by RotationSpeed * DeltaTime
+
+    Provide only the Python file content.
+
+    Parsed: {parsed}
+    Mapping: {mapping}
+    """
+
+    if backend == "hf":
+        return generate_with_hf(prompt)
+    else:
+        return generate_with_openai(prompt)

translator/synth_cpp.py

@@ -0,0 +1,25 @@
+from .llm_client import generate_with_hf, generate_with_openai
+
+def synthesize_cpp(parsed: dict, mapping: dict, backend: str = "hf", prompt_context: str = "") -> str:
+    """
+    Converts Unity C# parsed structure into Unreal Engine C++ (header + source).
+    """
+    prompt = f"""
+    Translate the following Unity C# class to idiomatic Unreal Engine C++ (header and source).
+    Mapping rules: {mapping}
+    Parsed structure: {parsed}
+
+    Generate two files separated with markers:
+    ---FILE: MyActor.h---
+    [contents]
+    ---FILE: MyActor.cpp---
+    [contents]
+
+    Be concise, compile-ready, and use UPROPERTY/UFUNCTION macros where suitable.
+    {prompt_context}
+    """
+
+    if backend == "hf":
+        return generate_with_hf(prompt)
+    else:
+        return generate_with_openai(prompt)