update changes

app.py

@@ -17,8 +17,8 @@ from config.constants import (
     SYSTEM_PROMPT_DUPLICATE_FINDER_EN,
     SYSTEM_PROMPT_ISSUE_ANALYZER_EN,
     SYSTEM_PROMPT_PRIORITIZER_EN,
-    SYSTEM_PROMPT_SKETCH,
-    SYSTEM_PROMPT_THEME_GENERATOR,
+    SYSTEM_PROMPT_SKETCH_EN,
+    SYSTEM_PROMPT_THEME_GENERATOR_EN,
 )
 from config.database import connect, initialize_database
 from config.model_factory import LLMFactory
@@ -30,6 +30,17 @@ load_dotenv()
 
 
 # region TOOLS FUNCTIONS
+def get_available_models():
+    """
+    Returns a JSON object listing all available LLM providers and their models.
+    Useful for agents to dynamically select valid parameters.
+    """
+    return {
+        "text_models": AVAILABLE_ISSUE_MODELS_BY_PROVIDER,
+        "vision_models": AVAILABLE_SKETCH_MODELS_BY_PROVIDER,
+        "providers": list(AVAILABLE_ISSUE_MODELS_BY_PROVIDER.keys())
+    }
+    
 def fetch_all_pages(url: str, headers: dict, progress: gr.Progress | None = None, desc: str = ""):
     """Helper function to fetch all pages from a paginated GitHub API endpoint."""
     results = []
@@ -59,15 +70,13 @@ def fetch_all_pages(url: str, headers: dict, progress: gr.Progress | None = None
 def sync_repository(repo_url: str, github_token: str | None = None, progress=gr.Progress(track_tqdm=True)):
     """
     Performs a lightweight sync of a GitHub repository with the local database.
-    It fetches only open issues and the most recent releases to ensure quick updates.
-
+    
     Args:
-        repo_url (str): The URL of the GitHub repository.
-        github_token (str | None): An optional GitHub token for higher API rate limits.
-        progress (gr.Progress): A Gradio Progress object to report status.
-
+        repo_url (str): The full URL of the GitHub repository (e.g., 'https://github.com/gradio-app/gradio').
+        github_token (str, optional): A GitHub Personal Access Token. Optional. If not provided, the tool will work but may hit public API rate limits.
+    
     Returns:
-        str: A status message indicating completion or failure.
+        str: A status message indicating completion.
     """
     if not repo_url:
         raise gr.Error("Please provide a repository URL.")
@@ -84,7 +93,7 @@ def sync_repository(repo_url: str, github_token: str | None = None, progress=gr.
         open_items = fetch_all_pages(issues_url, headers)
         for item in progress.tqdm(open_items, desc="Syncing Open Issues"):
             if "pull_request" in item:
-                continue  # We only want to sync actual issues here
+                continue
             item_labels = json.dumps([label["name"] for label in item["labels"]])
 
             cursor.execute(
@@ -109,7 +118,7 @@ def sync_repository(repo_url: str, github_token: str | None = None, progress=gr.
                     item.get("body"),
                     item["state"],
                     item["user"]["login"],
-                    item_labels, # Use the dumped JSON string here
+                    item_labels,
                     item["comments"],
                     item.get("reactions", {}).get("total_count", 0),
                     item["created_at"],
@@ -118,18 +127,7 @@ def sync_repository(repo_url: str, github_token: str | None = None, progress=gr.
                 ),
             )
 
-        # 2. Sync RECENT releases only
-        # releases_url = f"https://api.github.com/repos/{owner}/{repo}/releases?per_page=50"
-        # latest_releases = requests.get(releases_url, headers=headers).json()
-        # for release in progress.tqdm(latest_releases, desc="Syncing Recent Releases"):
-        #     cursor.execute(
-        #         """
-        #         INSERT INTO releases (repo, tag_name, name, body, published_at)
-        #         VALUES (%s, %s, %s, %s, %s)
-        #         ON CONFLICT (tag_name) DO NOTHING;
-        #         """,
-        #         (repo_slug, release["tag_name"], release["name"], release.get("body"), release["published_at"]),
-        #     )
+        # 2. Sync ALL releases
         releases_url = f"https://api.github.com/repos/{owner}/{repo}/releases?per_page=100"
         all_releases = fetch_all_pages(releases_url, headers, progress, desc="Syncing All Releases")
         for release in progress.tqdm(all_releases, desc="Saving Releases"):
@@ -147,30 +145,44 @@ def sync_repository(repo_url: str, github_token: str | None = None, progress=gr.
 
     except Exception as e:
         import traceback
-
         traceback.print_exc()
-        raise gr.Error(f"Sync failed: {e}")
+                
+        error_msg = str(e)        
+        if "429" in error_msg or "Rate" in error_msg:
+            detailed_msg = f"Rate Limit Error: The AI provider is busy. Please wait a moment."
+        else:
+            detailed_msg = f"System Error: {error_msg}"
+        
+        raise gr.Error(detailed_msg)
 
 
 def analyze_github_issue(
-    repo_url: str, issue_number: str, llm_provider: str, llm_model: str, github_token: str | None = None, progress=gr.Progress(track_tqdm=True)
+    repo_url: str,
+    issue_number: str,
+    llm_provider: str = "gemini",
+    llm_model: str = "gemini-2.0-flash",
+    github_token: str | None = None,
+    llm_api_key: str | None = None,
+    request: gr.Request = None,
+    progress=gr.Progress(track_tqdm=True)
 ):
     """
-    Analyzes a single GitHub issue by fetching its context (details, PRs, comments)
-    just-in-time and cross-referencing it with release notes from the local cache.
+    Analyzes a single GitHub issue to determine its resolution status by checking PRs and Releases.
 
     Args:
-        repo_url (str): The URL of the GitHub repository.
-        issue_number (str): The number of the issue to analyze.
-        llm_provider (str): The provider of the large language model.
-        llm_model (str): The specific model to use for analysis.
-        github_token (str | None): An optional GitHub token for API calls.
-        progress (gr.Progress): A Gradio Progress object to report status.
-
+        repo_url (str): The full URL of the GitHub repository.
+        issue_number (str): The issue number to analyze (e.g., '1234').
+        llm_provider (str, optional): The LLM provider to use. Defaults to 'gemini'.
+        llm_model (str, optional): The specific model name. Defaults to 'gemini-2.0-flash'.
+        github_token (str, optional): GitHub Token. Optional. Recommended for higher rate limits.
+        llm_api_key (str, optional): API Key for the LLM. **OPTIONAL**. If not provided (empty string), the server will use its internal environment keys to perform the analysis.
+    
     Returns:
-        str: An HTML-formatted analysis report or an error message.
+        str: An HTML-formatted analysis report.
     """
     try:
+        _validate_api_keys(llm_api_key, request)
+         
         if not repo_url or not issue_number:
             return "## Error\nPlease provide both a repository URL and an issue number."
 
@@ -201,7 +213,6 @@ def analyze_github_issue(
                 pr_num = event["source"]["issue"]["number"]
                 pr_urls_to_fetch.append(f"https://api.github.com/repos/{repo_slug}/pulls/{pr_num}")
 
-        # Fetch PR details
         for i, url in enumerate(pr_urls_to_fetch):
             progress(0.4 + (0.2 * (i / len(pr_urls_to_fetch))) if pr_urls_to_fetch else 0.4, desc=f"Fetching details for PR {i + 1}/{len(pr_urls_to_fetch)}...")
             pr_res = requests.get(url, headers=headers)
@@ -210,8 +221,8 @@ def analyze_github_issue(
 
         # 2. GET RELEASE DATA FROM CACHE
         progress(0.6, desc="Querying local release cache...")
-        releases_cursor = cursor.execute("SELECT * FROM releases WHERE repo = %s ORDER BY published_at DESC LIMIT 50", (repo_slug,))
-        releases = releases_cursor.fetchall()
+        cursor.execute("SELECT * FROM releases WHERE repo = %s ORDER BY published_at DESC LIMIT 50", (repo_slug,))
+        releases = cursor.fetchall()
         conn.close()
 
         # 3. SUMMARIZE COMMENTS
@@ -222,12 +233,16 @@ def analyze_github_issue(
             try:
                 summarizer_prompt = SYSTEM_PROMPT_COMMENT_SUMMARIZER_EN.format(comments_text=comments_text)
                 additional_problems_summary = LLMFactory.call(
-                    llm_provider, llm_model, messages=[{"role": "user", "content": summarizer_prompt}], temperature=0.0
+                    llm_provider,
+                    llm_model,
+                    messages=[{"role": "user", "content": summarizer_prompt}],
+                    temperature=0.0,
+                    api_key=llm_api_key
                 )
             except Exception:
                 additional_problems_summary = "Could not summarize comments due to an error."
 
-        # 4. FORMAT CONTEXT FOR MAIN ANALYSIS LLM
+        # 4. FORMAT CONTEXT
         progress(0.8, desc="Preparing final analysis...")
 
         pull_requests_summary = (
@@ -243,7 +258,7 @@ def analyze_github_issue(
 
         release_notes_summary = (
             "\n\n".join(
-                [f"- **Release {r['tag_name']} ({r['published_at'][:10]}):**\n{str(r['body'])[:500] if r['body'] else 'No description.'}..." for r in releases]
+                [f"- **Release {r['tag_name']} ({str(r['published_at'])[:10]}):**\n{str(r['body'])[:500] if r['body'] else 'No description.'}..." for r in releases]
             )
             if releases
             else "No releases found in local cache."
@@ -265,10 +280,15 @@ def analyze_github_issue(
         progress(0.9, desc="Generating final report with AI...")
 
         messages = [{"role": "user", "content": final_prompt}]
-        raw_output = LLMFactory.call(llm_provider, llm_model, messages=messages, temperature=0.1, max_tokens=2048)
-        if isinstance(raw_output, str) and raw_output.startswith("Error:"):
-            raise Exception(raw_output)
-
+        raw_output = LLMFactory.call(
+            llm_provider,
+            llm_model,
+            messages=messages,
+            temperature=0.1,
+            max_tokens=2048,
+            api_key=llm_api_key
+        )
+       
         report_start_marker = f"## Analysis of Issue #{issue_number}"
         report_start_index = raw_output.find(report_start_marker)
 
@@ -291,37 +311,50 @@ def analyze_github_issue(
             </span>
         </div>
         """
-
-        # Convert the LLM's Markdown analysis to HTML
         analysis_html = markdown.markdown(analysis.strip())
+        return provider_seal_html + analysis_html
 
-        # Combine the two HTML parts
-        final_html_output = provider_seal_html + analysis_html
-        return final_html_output
     except Exception as e:
         import traceback
-
         traceback.print_exc()
-        return f"## Analysis Error\n**Details:** `{str(e)}`"
-
-
-def find_duplicate_issues(repo_url: str, issue_number: str, llm_provider: str, llm_model: str, github_token: str | None = None, progress=gr.Progress()):
+                
+        error_msg = str(e)
+        if "Auth" in error_msg or "Key" in error_msg or "401" in error_msg:
+            detailed_msg = f"Authentication Error: The provided API Key for {llm_provider} is invalid or expired."
+        elif "429" in error_msg or "Rate" in error_msg:
+            detailed_msg = f"Rate Limit Error: The AI provider is busy. Please wait a moment."
+        else:
+            detailed_msg = f"System Error: {error_msg}"
+        
+        raise gr.Error(detailed_msg)
+
+
+def find_duplicate_issues(
+    repo_url: str,
+    issue_number: str,
+    llm_provider: str = "gemini",
+    llm_model: str = "gemini-2.0-flash",
+    github_token: str | None = None,
+    llm_api_key: str | None = None,
+    request: gr.Request = None,
+    progress=gr.Progress()
+):
     """
-    Finds potential duplicate issues for a given issue.
-    It combines a real-time search for mentions in the issue's timeline with a
-    keyword-based search against the local cache of open issues.
-
+    Finds potential duplicate issues for a given issue using mentions and keyword search.
+    
     Args:
-        repo_url (str): The URL of the GitHub repository.
-        issue_number (str): The number of the main issue to check for duplicates.
-        llm_provider (str): The provider of the large language model.
-        llm_model (str): The specific model to use for analysis.
-        github_token (str | None): An optional GitHub token for API calls.
-        progress (gr.Progress): A Gradio Progress object to report status.
-
+        repo_url (str): The full URL of the GitHub repository.
+        issue_number (str): The main issue number to check.
+        llm_provider (str, optional): The LLM provider. Defaults to 'gemini'.
+        llm_model (str, optional): The model name. Defaults to 'gemini-2.0-flash'.
+        github_token (str, optional): GitHub Token. Optional.
+        llm_api_key (str, optional): API Key for the LLM. **OPTIONAL**. If not provided, the server uses its own keys.
+    
     Returns:
-        str: A Markdown-formatted report of potential duplicates.
+        str: A Markdown list of potential duplicates.
     """
+    _validate_api_keys(llm_api_key, request)
+            
     if not repo_url or not issue_number:
         return "Please provide the repository and the main issue number."
 
@@ -333,12 +366,14 @@ def find_duplicate_issues(repo_url: str, issue_number: str, llm_provider: str, l
         cursor = conn.cursor()
 
         progress(0, desc="Fetching main issue from cache...")
-        main_issue = cursor.execute("SELECT * FROM items WHERE repo = %s AND number = %s", (repo_slug, issue_number)).fetchone()
+        cursor.execute("SELECT * FROM items WHERE repo = %s AND number = %s", (repo_slug, issue_number))
+        main_issue = cursor.fetchone()
+        
         if not main_issue:
             conn.close()
             return "Main issue not found in cache. Please synchronize the repository first."
 
-        # STEP 1: GATHER MENTIONS VIA TIMELINE API
+        # STEP 1: GATHER MENTIONS
         progress(0.2, desc="Fetching timeline for mentions...")
         timeline_api_url = f"https://api.github.com/repos/{owner}/{repo}/issues/{issue_number}/timeline?per_page=100"
         timeline_events = fetch_all_pages(timeline_api_url, headers)
@@ -354,13 +389,14 @@ def find_duplicate_issues(repo_url: str, issue_number: str, llm_provider: str, l
         if not mentions_summary:
             mentions_summary = "No other issues or PRs were found mentioning this issue in its timeline."
 
-        # STEP 2: SEARCH FOR CANDIDATES BY KEYWORD (FROM CACHE)
+        # STEP 2: SEARCH CANDIDATES
         progress(0.5, desc="Searching for candidates in cache...")
         main_issue_title = main_issue["title"]
         keywords = [word for word in re.findall(r"\b\w+\b", main_issue_title) if len(word) > 3]
         query_conditions = " OR ".join([f"title LIKE '%{keyword}%'" for keyword in keywords])
-        candidate_query = f"SELECT * FROM items WHERE repo = '{repo_slug}' AND is_pr = 0 AND state = 'open' AND ({query_conditions})"
-        candidate_issues = cursor.execute(candidate_query).fetchall()
+        candidate_query = f"SELECT * FROM items WHERE repo = '{repo_slug}' AND is_pr = FALSE AND state = 'open' AND ({query_conditions})"
+        cursor.execute(candidate_query)
+        candidate_issues = cursor.fetchall()
         conn.close()
 
         candidate_issues_summary = ""
@@ -373,7 +409,7 @@ def find_duplicate_issues(repo_url: str, issue_number: str, llm_provider: str, l
         if not candidate_issues_summary:
             candidate_issues_summary = "No similar open issues found via keyword search."
 
-        # STEP 3: FORMAT CONTEXT AND CALL LLM
+        # STEP 3: LLM ANALYSIS
         progress(0.8, desc="Analyzing for duplicates with AI...")
         prompt_context = {
             "main_issue_number": main_issue["number"],
@@ -385,31 +421,51 @@ def find_duplicate_issues(repo_url: str, issue_number: str, llm_provider: str, l
         final_prompt = SYSTEM_PROMPT_DUPLICATE_FINDER_EN.format(**prompt_context)
 
         messages = [{"role": "user", "content": final_prompt}]
-        analysis = LLMFactory.call(llm_provider, llm_model, messages=messages, temperature=0.0)
-
+        analysis = LLMFactory.call(
+            llm_provider,
+            llm_model,
+            messages=messages,
+            temperature=0.0,
+            api_key=llm_api_key
+        )
         return analysis
 
     except Exception as e:
         import traceback
-
         traceback.print_exc()
-        return f"## Error Finding Duplicates\n**Details:** `{str(e)}`"
-
-
-def prioritize_open_issues(repo_url: str, llm_provider: str, llm_model: str, progress=gr.Progress(track_tqdm=True)):
+                
+        error_msg = str(e)
+        if "Auth" in error_msg or "Key" in error_msg or "401" in error_msg:
+            detailed_msg = f"Authentication Error: The provided API Key for {llm_provider} is invalid or expired."
+        elif "429" in error_msg or "Rate" in error_msg:
+            detailed_msg = f"Rate Limit Error: The AI provider is busy. Please wait a moment."
+        else:
+            detailed_msg = f"System Error: {error_msg}"
+        
+        raise gr.Error(detailed_msg)
+
+def prioritize_open_issues(
+    repo_url: str,
+    llm_provider: str = "gemini",
+    llm_model: str = "gemini-2.0-flash",
+    llm_api_key: str | None = None,
+    request: gr.Request = None,
+    progress=gr.Progress(track_tqdm=True)
+):
     """
-    Analyzes open issues from the local cache to create a prioritized backlog for developers.
-    It fetches issues based on engagement (comments, reactions) and uses an LLM to rank them.
-
+    Analyzes open issues from the cache to create a prioritized backlog.
+    
     Args:
         repo_url (str): The URL of the GitHub repository.
-        llm_provider (str): The provider of the large language model.
-        llm_model (str): The specific model to use for prioritization.
-        progress (gr.Progress): A Gradio Progress object to report status.
-
+        llm_provider (str, optional): The LLM provider. Defaults to 'gemini'.
+        llm_model (str, optional): The model name. Defaults to 'gemini-2.0-flash'.
+        llm_api_key (str, optional): API Key for the LLM. **OPTIONAL**. If not provided, the server uses its own keys.
+    
     Returns:
-        str: A Markdown-formatted prioritized list of issues.
+        str: A Markdown priority list.
     """
+    _validate_api_keys(llm_api_key, request)
+    
     if not repo_url:
         return "Please provide the repository URL."
 
@@ -418,22 +474,20 @@ def prioritize_open_issues(repo_url: str, llm_provider: str, llm_model: str, pro
         conn = connect()
         cursor = conn.cursor()
 
-        # 1. Fetch all open issues from the cache, ordered by engagement
         progress(0, desc="Fetching open issues from cache...")
-        # Order by comments and reactions to get the most "active" issues
-        open_issues = cursor.execute(
-            "SELECT * FROM items WHERE repo = %s AND is_pr = 0 AND state = 'open' ORDER BY comments DESC, reactions DESC LIMIT 50", (repo_slug,)
-        ).fetchall()
+        cursor.execute(
+            "SELECT * FROM items WHERE repo = %s AND is_pr = FALSE AND state = 'open' ORDER BY comments DESC, reactions DESC LIMIT 50", (repo_slug,)
+        )
+        open_issues = cursor.fetchall()
         conn.close()
 
         if not open_issues:
             return "No open issues found in the cache to prioritize."
 
-        # 2. Format the context for the LLM
         progress(0.5, desc="Preparing context for prioritization...")
         issues_list_summary = ""
         for issue in open_issues:
-            labels = json.loads(issue["labels"]) if issue["labels"] else "None"
+            labels = issue["labels"] if issue["labels"] else "None"
             issues_list_summary += (
                 f'- **Issue #{issue["number"]}**: "{issue["title"]}"\n'
                 f"  - **Labels**: {labels}\n"
@@ -443,27 +497,114 @@ def prioritize_open_issues(repo_url: str, llm_provider: str, llm_model: str, pro
         prompt_context = {"issues_list_summary": issues_list_summary}
         final_prompt = SYSTEM_PROMPT_PRIORITIZER_EN.format(**prompt_context)
 
-        # 3. Call LLM for analysis
         progress(0.8, desc="Generating priority list with AI...")
         messages = [{"role": "user", "content": final_prompt}]
-        analysis = LLMFactory.call(llm_provider, llm_model, messages=messages, temperature=0.1, max_tokens=4096)
-
+        analysis = LLMFactory.call(
+            llm_provider,
+            llm_model,
+            messages=messages,
+            temperature=0.1,
+            max_tokens=4096,
+            api_key=llm_api_key
+        )
         return analysis
 
     except Exception as e:
         import traceback
-
         traceback.print_exc()
-        return f"## Error During Prioritization\n**Details:** `{str(e)}`"
+                
+        error_msg = str(e)
+        if "Auth" in error_msg or "Key" in error_msg or "401" in error_msg:
+            detailed_msg = f"Authentication Error: The provided API Key for {llm_provider} is invalid or expired."
+        elif "429" in error_msg or "Rate" in error_msg:
+            detailed_msg = f"Rate Limit Error: The AI provider is busy. Please wait a moment."
+        else:
+            detailed_msg = f"System Error: {error_msg}"
+        
+        raise gr.Error(detailed_msg)
+
+def reply_and_close_issue(
+    repo_url: str,
+    issue_number: str,
+    comment_body: str,
+    close_issue: bool = False,
+    github_token: str | None = None,
+    request: gr.Request = None
+):
+    """
+    Posts a comment on a GitHub issue and optionally closes it.
+    Crucial for the 'Actionable AI' capability.
+    
+    Args:
+        repo_url (str): Full repository URL.
+        issue_number (str): The issue number.
+        comment_body (str): The markdown text to post as a comment.
+        close_issue (bool): If True, changes the issue state to 'closed'.
+        github_token (str): MANDATORY. A GitHub token with write permissions.
+    """
+    # Security check: This tool ALWAYS requires a token via API or UI
+    if not github_token:
+        raise gr.Error("⚠️ Write Permission Error: A GitHub Token is mandatory for posting comments or closing issues.")
 
+    try:
+        owner, repo = repo_url.strip().replace("https://github.com/", "").split("/")
+        repo_slug = f"{owner}/{repo}"
+        headers = {
+            "Authorization": f"token {github_token}",
+            "Accept": "application/vnd.github.v3+json"
+        }
 
-def generate_theme(prompt: str, llm_provider: str, llm_model: str):
+        # 1. Post the Comment
+        if comment_body and comment_body.strip():
+            comment_url = f"https://api.github.com/repos/{repo_slug}/issues/{issue_number}/comments"
+            comment_resp = requests.post(comment_url, headers=headers, json={"body": comment_body})
+            comment_resp.raise_for_status()
+            action_log = f"✅ Comment posted on issue #{issue_number}."
+        else:
+            action_log = "ℹ️ No comment body provided, skipping comment."
+
+        # 2. Close the Issue (if requested)
+        if close_issue:
+            issue_url = f"https://api.github.com/repos/{repo_slug}/issues/{issue_number}"
+            # state_reason can be 'completed' or 'not_planned'
+            close_resp = requests.patch(issue_url, headers=headers, json={"state": "closed", "state_reason": "completed"})
+            close_resp.raise_for_status()
+            action_log += f"\n🔒 Issue #{issue_number} has been CLOSED."
+        
+        return f"## Success\n{action_log}"
+
+    except requests.exceptions.HTTPError as e:
+        if e.response.status_code == 404:
+            raise gr.Error("Error 404: Repo or Issue not found (or Token lacks permission).")
+        if e.response.status_code == 401:
+            raise gr.Error("Error 401: Invalid GitHub Token.")
+        raise gr.Error(f"GitHub API Error: {e}")
+    except Exception as e:
+        import traceback
+        traceback.print_exc()
+        raise gr.Error(f"System Error: {str(e)}")
+
+def generate_theme(
+    prompt: str,
+    llm_provider: str = "gemini",
+    llm_model: str = "gemini-2.0-flash",
+    llm_api_key: str | None = None,
+    request: gr.Request = None
+):
     """
-    Tool 1 function: Generates a complete theme from a text prompt.
+    Generates a Gradio theme based on a text prompt.
+    
+    Args:
+        prompt (str): Description of the desired theme.
+        llm_provider (str, optional): LLM provider. Defaults to 'gemini'.
+        llm_model (str, optional): Model name. Defaults to 'gemini-2.0-flash'.
+        llm_api_key (str, optional): API Key. **OPTIONAL**. If empty, uses server keys.
     """
+    _validate_api_keys(llm_api_key, request)
+    
     try:
-        messages = [{"role": "system", "content": SYSTEM_PROMPT_THEME_GENERATOR}, {"role": "user", "content": prompt}]
-        llm_output = LLMFactory.call(llm_provider=llm_provider, llm_model=llm_model, messages=messages, temperature=0.1, max_tokens=2048)
+        messages = [{"role": "system", "content": SYSTEM_PROMPT_THEME_GENERATOR_EN}, {"role": "user", "content": prompt}]
+        llm_output = LLMFactory.call(llm_provider=llm_provider, llm_model=llm_model, messages=messages, temperature=0.1, max_tokens=2048, api_key=llm_api_key)
 
         if isinstance(llm_output, str) and llm_output.startswith("Error:"):
             raise Exception(llm_output)
@@ -474,6 +615,7 @@ def generate_theme(prompt: str, llm_provider: str, llm_model: str):
         constructor_kwargs = theme_config.constructor_args.model_dump(exclude_unset=True)
         set_kwargs = theme_config.set_args.model_dump(exclude_unset=True)
 
+        # Clean up color refs
         for key in list(set_kwargs.keys()):
             value = set_kwargs[key]
             if isinstance(value, str) and value.startswith("*"):
@@ -481,10 +623,8 @@ def generate_theme(prompt: str, llm_provider: str, llm_model: str):
                     name, shade = value[1:].rsplit("_", 1)
                     shade_num = int(shade)
                     if not (50 <= shade_num <= 950):
-                        print(f"WARNING: Invalid color ref: {value}. Ignoring.")
                         del set_kwargs[key]
                 except (ValueError, IndexError):
-                    print(f"WARNING: Malformed color ref: {value}. Ignoring.")
                     del set_kwargs[key]
 
         if "font" in constructor_kwargs:
@@ -504,8 +644,7 @@ def generate_theme(prompt: str, llm_provider: str, llm_model: str):
         css_str = theme_object._get_theme_css()
 
         def format_arg(val):
-            if isinstance(val, str):
-                return f"'{val}'"
+            if isinstance(val, str): return f"'{val}'"
             if isinstance(val, list):
                 font_list = [f"gr.themes.GoogleFont('{f.name}')" if isinstance(f, gr.themes.GoogleFont) else f"'{f}'" for f in val]
                 return f"[{', '.join(font_list)}]"
@@ -519,21 +658,23 @@ def generate_theme(prompt: str, llm_provider: str, llm_model: str):
         return theme_object, py_code, status_message, css_str
 
     except Exception as e:
-        error_message = f"An error occurred: {e}."
-        return None, "", error_message, ""
+        import traceback
+        traceback.print_exc()
+                
+        error_msg = str(e)
+        if "Auth" in error_msg or "Key" in error_msg or "401" in error_msg:
+            detailed_msg = f"Authentication Error: The provided API Key for {llm_provider} is invalid or expired."
+        elif "429" in error_msg or "Rate" in error_msg:
+            detailed_msg = f"Rate Limit Error: The AI provider is busy. Please wait a moment."
+        else:
+            detailed_msg = f"System Error: {error_msg}"
+        
+        raise gr.Error(detailed_msg)
 
 
 def handle_upload(theme_obj, theme_name, hf_token):
     """
-    Handles uploading the generated theme to Hugging Face Hub.
-
-    Args:
-        theme_obj (gr.themes.Base): The Gradio theme object to be uploaded.
-        theme_name (str): The desired name for the repository on the Hub.
-        hf_token (str): The Hugging Face API token for authentication.
-
-    Returns:
-        gr.Markdown: A Gradio Markdown component with the success or error message.
+    Handles uploading the generated theme.
     """
     if not isinstance(theme_obj, gr.themes.Base):
         return gr.Markdown("⚠️ Please generate a theme first.", visible=True)
@@ -548,59 +689,74 @@ def handle_upload(theme_obj, theme_name, hf_token):
         return gr.Markdown(f"❌ **Error:** {e}", visible=True)
 
 
-def generate_ui_from_sketch(sketch_image, text_description: str, llm_provider: str, llm_model: str):
+def generate_ui_from_sketch(
+    sketch_image,
+    text_description: str,
+    llm_provider: str = "sambanova",
+    llm_model: str = "Llama-4-Maverick-17B-128E-Instruct",
+    llm_api_key: str | None = None,
+    request: gr.Request = None
+):
     """
-    Generates Python code for a Gradio UI from a sketch image and an optional text description.
-
+    Generates Python code for a Gradio UI from a sketch image.
+    
     Args:
-        sketch_image (Image): The sketch image provided.
-        text_description (str): Additional text description to guide the generation.
-        llm_provider (str): The provider of the large language model.
-        llm_model (str): The specific model to use for generation.
-
-    Returns:
-        str: The generated Python code as a string, or an error message.
+        sketch_image (Image): The input sketch image.
+        text_description (str): Optional text description.
+        llm_provider (str, optional): Defaults to 'sambanova'.
+        llm_model (str, optional): Defaults to 'Llama-4-Maverick-17B-128E-Instruct'.
+        llm_api_key (str, optional): API Key. **OPTIONAL**. If empty, uses server keys.
     """
+    _validate_api_keys(llm_api_key, request)
+
     if sketch_image is None:
         return "# Please draw or upload an image."
 
     try:
         messages = [
-            {"role": "system", "content": SYSTEM_PROMPT_SKETCH},
+            {"role": "system", "content": SYSTEM_PROMPT_SKETCH_EN},
             {"role": "user", "content": f"Additional text description: {text_description if text_description else 'None'}"},
         ]
 
-        llm_output = LLMFactory.call(llm_provider=llm_provider, llm_model=llm_model, messages=messages, image=sketch_image, temperature=0.1, max_tokens=8192)
+        llm_output = LLMFactory.call(llm_provider=llm_provider, llm_model=llm_model, messages=messages, image=sketch_image, temperature=0.1, max_tokens=8192, api_key=llm_api_key)
 
         if isinstance(llm_output, str) and llm_output.startswith("Error:"):
             raise Exception(llm_output)
 
         code = llm_output.split("```python\n")[1].split("\n```")[0] if "```python" in llm_output else llm_output
-
         return code.strip()
     except Exception as e:
-        error_message = f"# An error occurred while generating the UI: {e}"
-        return error_message
+        import traceback
+        traceback.print_exc()
+                
+        error_msg = str(e)
+        if "Auth" in error_msg or "Key" in error_msg or "401" in error_msg:
+            detailed_msg = f"Authentication Error: The provided API Key for {llm_provider} is invalid or expired."
+        elif "429" in error_msg or "Rate" in error_msg:
+            detailed_msg = f"Rate Limit Error: The AI provider is busy. Please wait a moment."
+        else:
+            detailed_msg = f"System Error: {error_msg}"
+        
+        raise gr.Error(detailed_msg)
 
 
 # endregion
 
 
 # region HELPER FUNCTIONS
-def check_env():
-    """
-    Checks for the presence of required environment variables and prints a warning if they are not set.
-    """
+def _validate_api_keys(llm_api_key, request):
+    USE_SERVER_KEYS = os.getenv("USE_SERVER_KEYS", "false").lower() in ("True", "true", "1", "yes")
+    if not USE_SERVER_KEYS and request and request.headers.get("referer"):
+        if not llm_api_key or not llm_api_key.strip():
+            raise gr.Error("⚠️ LLM API Key Required! Please enter your own API Key to use this tool in the demo UI.")
+        
+def _check_env():
     if not os.getenv("GOOGLE_API_KEY"):
         print("WARNING: The GOOGLE_API_KEY environment variable was not set.")
     if not os.getenv("SAMBANOVA_API_KEY"):
         print("WARNING: The SAMBANOVA_API_KEY environment variable was not set.")
 
-
-def inject_theme_helper_js():
-    """
-    Called by app.load() of the main page. Returns a dictionary for HTMLInjector.
-    """
+def _inject_theme_helper_js():
     js_code = """
         function apply_gradio_theme(css) {
             let style_tag = document.getElementById('dynamic_theme_css');
@@ -610,20 +766,12 @@ def inject_theme_helper_js():
                 document.head.appendChild(style_tag);
             }
             style_tag.innerHTML = css;
-            console.log('✅ Helper: Theme applied via global function.');
         }
         document.dispatchEvent(new CustomEvent('theme-helper-injected'));
-        console.log('Injector: apply_gradio_theme() function injected and event fired.');
     """
     return {"js": js_code}
 
-
-def add_interactive_inputs():
-    """
-    Creates a set of interactive input components for the theme preview.
-    Returns:
-        tuple: A tuple of the created Gradio components.
-    """
+def _add_interactive_inputs():
     with gr.Row():
         with gr.Column(variant="panel", scale=1):
             gr.Markdown("### Interactive Controls")
@@ -640,22 +788,13 @@ def add_interactive_inputs():
                 gr.Button("Small", size="sm")
                 gr.UploadButton(size="sm")
                 gr.Button("Stop", variant="stop", size="sm")
-
     return radio, drop, drop_2, check
 
-
-def add_data_display_components():
-    """
-    Creates a set of data display components for the theme preview.
-    """
+def _add_data_display_components():
     with gr.Row():
         gr.Dataframe(value=[[1, 2], [3, 4]], label="Dataframe"), gr.JSON(value={"a": 1}), gr.Label(value={"cat": 0.7}), gr.File()
 
-
-def add_media_components():
-    """
-    Creates a set of media-related components for the theme preview.
-    """
+def _add_media_components():
     with gr.Row():
         (
             gr.ColorPicker(label="Color Picker"),
@@ -663,13 +802,7 @@ def add_media_components():
             gr.Gallery([("https://gradio-static-files.s3.us-west-2.amazonaws.com/lion.jpg", "lion")], height="200px"),
         )
 
-
-def add_chatbot_component():
-    """
-    Creates a chatbot interface for the theme preview.
-    Returns:
-        tuple: A tuple of the created Gradio components (chatbot, input, button).
-    """
+def _add_chatbot_component():
     with gr.Row():
         with gr.Column(scale=2):
             chatbot = gr.Chatbot([{"role": "user", "content": "Hello"}], label="Chatbot", type="messages")
@@ -680,14 +813,7 @@ def add_chatbot_component():
                 gr.Slider(label="Temperature"), gr.Checkbox(label="Streaming")
     return chatbot, msg_input, add_msg_btn
 
-
-def create_example_app():
-    """
-    Builds the complete example application used for theme previewing.
-    It assembles various components into a tabbed interface.
-    Returns:
-        tuple: A tuple of components from the chatbot interface for event handling.
-    """
+def _create_example_app():
     with gr.Column(scale=3, elem_id="app"):
         with gr.Tabs():
             with gr.TabItem("Common Inputs"):
@@ -697,29 +823,63 @@ def create_example_app():
                     gr.Slider(label="Slider 1")
                     gr.Slider(label="Slider 2")
                     gr.CheckboxGroup(["A", "B", "C"], label="Checkbox Group")
-                radio, drop, drop_2, check = add_interactive_inputs()
+                radio, drop, drop_2, check = _add_interactive_inputs()
                 gr.Examples(
                     examples=[["A", "Option 1", ["B"], True], ["B", "Option 2", ["A", "C"], False]], inputs=[radio, drop, drop_2, check], label="Input Examples"
                 )
             with gr.TabItem("Data and Media"):
-                add_data_display_components()
-                add_media_components()
-
+                _add_data_display_components()
+                _add_media_components()
             with gr.TabItem("Layout and Chat"):
-                chatbot, msg_input, add_msg_btn = add_chatbot_component()
-
+                chatbot, msg_input, add_msg_btn = _add_chatbot_component()
     return chatbot, msg_input, add_msg_btn
 
-
+def _create_gradio_lite_html(python_code: str) -> str:
+    """
+    Wraps the Python code in a Gradio-Lite HTML structure with an iframe.
+    This ensures the preview runs isolated from the main app.
+    """
+    # Escape any existing script tags to prevent injection issues inside srcdoc
+    safe_code = python_code.replace("<", "&lt;").replace(">", "&gt;")
+    
+    # To make sure demo.launch() is present for Lite to render
+    if "demo.launch()" not in safe_code:
+        safe_code += "\n\ndemo.launch()"
+
+    html_template = f"""
+    <div style="width: 100%; height: 600px; border: 1px solid #e5e7eb; border-radius: 8px; overflow: hidden;">
+        <iframe
+            srcdoc='
+            <!DOCTYPE html>
+            <html>
+                <head>
+                    <script type="module" crossorigin src="https://gradio-lite-previews.s3.amazonaws.com/PINNED_HF_HUB/dist/lite.js"></script>
+                    <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/@gradio/lite/dist/lite.css" />
+                    <style>
+                        body {{ margin: 0; padding: 0; height: 100vh; }}
+                        gradio-lite {{ width: 100%; height: 100%; display: block; }}
+                    </style>
+                </head>
+                <body>
+                    <gradio-lite>
+                        {safe_code}
+                    </gradio-lite>
+                </body>
+            </html>'
+            width="100%"
+            height="100%"
+            style="border: none;"
+            sandbox="allow-scripts allow-same-origin"
+        ></iframe>
+    </div>
+    """
+    return html_template
 # endregion
 
 # region MAIN LAYOUT DEFINITION
 css = """
 .gradio-container { max-width: none !important; }
-.fillable {
-width: 100% !important;
-max-width: unset !important;
-}
+.fillable { width: 100% !important; max-width: unset !important; }
 #app { height: 100vh; overflow-y: scroll; }
 """
 
@@ -730,73 +890,89 @@ with gr.Blocks(css=css, title="GitRepo Inspector (MCP Server)") as app:
 
     gr.Markdown("# 🤖 GitRepo Inspector (MCP Server) 🤖")
 
+    # --- GLOBAL CONFIGURATION ---
+    with gr.Accordion("⚙️ Global Configuration (Configure tools here)", open=True):
+        with gr.Row():
+            global_github_token = gr.Textbox(
+                label="GitHub Token", 
+                type="password",
+                placeholder="Optional for public repos, required for higher rate limits."
+            )
+            global_api_key = gr.Textbox(
+                label="LLM API Key", 
+                type="password",
+                placeholder="Required for UI demo. (Matches selected Provider)"
+            )
+        with gr.Row():
+            global_provider = gr.Dropdown(
+                choices=list(AVAILABLE_ISSUE_MODELS_BY_PROVIDER.keys()), 
+                value="gemini", 
+                label="LLM Provider (For all tools)"
+            )
+            global_model = gr.Dropdown(
+                choices=AVAILABLE_ISSUE_MODELS_BY_PROVIDER["gemini"], 
+                value=AVAILABLE_ISSUE_MODELS_BY_PROVIDER["gemini"][0], 
+                label="Main Model (Text/Chat)", 
+                interactive=True
+            )
+        with gr.Row():        
+            models_info_output = gr.JSON(label="Available Models Registry", visible=False) 
+            get_models_btn = gr.Button("Refresh Models Info", visible=False) 
+    # -----------------------------
+
     with gr.Tabs():
         with gr.TabItem("1. Sync Repo"):
             gr.Markdown("### 🔄 Synchronize Repository with Local Cache")
-            gr.Markdown(
-                "Before using the analysis tools, fetch the latest data from a GitHub repository. This sync fetches open issues and recent releases, making other tools faster."
-            )
+            gr.Markdown("Fetch open issues and recent releases to speed up analysis.")
             sync_repo_url = gr.Textbox(label="Repository URL", value="https://github.com/gradio-app/gradio")
-            sync_github_token = gr.Textbox(label="GitHub Token (Recommended for higher rate limits)", type="password")
             sync_button = gr.Button("Start Synchronization", variant="primary")
             sync_status_output = gr.Textbox(label="Sync Status", interactive=False)
 
         with gr.TabItem("2. Issue Analyzer"):
             gr.Markdown("### 🔍 Analyze a GitHub Issue")
-            gr.Markdown(
-                "Provide a repository URL and an issue number to check if it has been addressed in a recent release or PR, using a combination of real-time data and the local cache."
-            )
             with gr.Row():
-                llm_issue_provider_dropdown = gr.Dropdown(choices=list(AVAILABLE_ISSUE_MODELS_BY_PROVIDER.keys()), value="gemini", label="LLM Provider")
-                llm_issue_model_dropdown = gr.Dropdown(
-                    choices=AVAILABLE_ISSUE_MODELS_BY_PROVIDER["gemini"], value=AVAILABLE_ISSUE_MODELS_BY_PROVIDER["gemini"][0], label="Model", interactive=True
-                )
-            with gr.Row():
-                issue_repo_url = gr.Textbox(
-                    label="GitHub Repository URL", value="https://github.com/gradio-app/gradio", placeholder="https://github.com/gradio-app/gradio"
-                )
+                issue_repo_url = gr.Textbox(label="GitHub Repository URL", value="https://github.com/gradio-app/gradio")
                 issue_number_input = gr.Number(label="Issue Number", precision=0)
-
-            issue_github_token = gr.Textbox(label="GitHub Token (Optional, for higher rate limits)", type="password")
             issue_analyze_button = gr.Button("Analyze Issue 🕵️", variant="primary")
             issue_report_output = gr.HTML(label="Analysis Report")
 
         with gr.TabItem("3. Issue Duplicate Finder"):
             gr.Markdown("### 👯 Find Duplicate Issues")
-            gr.Markdown("Provide a repository and a main issue number to find potential duplicates using the local cache and timeline mentions.")
             with gr.Row():
                 dup_repo_url = gr.Textbox(label="Repository URL", value="https://github.com/gradio-app/gradio")
                 dup_issue_number = gr.Number(label="Main Issue #", precision=0)
-            with gr.Row():
-                dup_llm_provider = gr.Dropdown(list(AVAILABLE_ISSUE_MODELS_BY_PROVIDER.keys()), value="gemini", label="LLM Provider")
-                dup_llm_model = gr.Dropdown(
-                    AVAILABLE_ISSUE_MODELS_BY_PROVIDER["gemini"], value=AVAILABLE_ISSUE_MODELS_BY_PROVIDER["gemini"][0], label="Model", interactive=True
-                )
-            dup_github_token = gr.Textbox(label="GitHub Token (Optional)", type="password")
             dup_find_button = gr.Button("Find Duplicates", variant="primary")
             dup_report_output = gr.Markdown(label="Duplicate Report")
 
         with gr.TabItem("4. Issue Prioritizer"):
             gr.Markdown("### 🥇 Prioritize Backlog")
-            gr.Markdown("Analyzes the most engaged open issues from the local cache and generates a priority list.")
             prio_repo_url = gr.Textbox(label="Repository URL", value="https://github.com/gradio-app/gradio")
-            with gr.Row():
-                prio_llm_provider = gr.Dropdown(list(AVAILABLE_ISSUE_MODELS_BY_PROVIDER.keys()), value="gemini", label="LLM Provider")
-                prio_llm_model = gr.Dropdown(
-                    AVAILABLE_ISSUE_MODELS_BY_PROVIDER["gemini"], value=AVAILABLE_ISSUE_MODELS_BY_PROVIDER["gemini"][0], label="Model", interactive=True
-                )
             prio_run_button = gr.Button("Generate Priority List", variant="primary")
             prio_report_output = gr.Markdown(label="Prioritized Backlog")
 
-        with gr.TabItem("BONUS 1 - Theme Generator"):
+        with gr.TabItem("5. Action Runner (Reply & Close)"):
+            gr.Markdown("### ⚡ Action Runner")
+            gr.Markdown("This tool allows the Agent (or you) to take action: post comments and close resolved issues.")
+            
             with gr.Row():
-                llm_theme_provider_dropdown = gr.Dropdown(choices=list(AVAILABLE_ISSUE_MODELS_BY_PROVIDER.keys()), value="gemini", label="LLM Provider")
-                llm_theme_model_dropdown = gr.Dropdown(
-                    choices=AVAILABLE_ISSUE_MODELS_BY_PROVIDER["gemini"], value=AVAILABLE_ISSUE_MODELS_BY_PROVIDER["gemini"][0], label="Model", interactive=True
-                )
+                action_repo_url = gr.Textbox(label="Repository URL", value="https://github.com/gradio-app/gradio")
+                action_issue_number = gr.Number(label="Issue Number", precision=0)
+            
+            action_comment = gr.Textbox(
+                label="Comment Body (Markdown supported)", 
+                lines=5, 
+                placeholder="Ex: This issue is resolved in PR #123. Closing now."
+            )
+            
+            action_close_checkbox = gr.Checkbox(label="Close this issue?", value=False, info="Check to verify the fix and close the issue on GitHub.")
+          
+            action_button = gr.Button("Execute Action ���", variant="stop") # Variant stop (vermelho) para indicar cuidado
+            action_output = gr.Markdown(label="Execution Result")
+            
+        with gr.TabItem("BONUS 1 - Theme Generator"):
+            gr.Markdown("### 🖌️ Create a Theme with Natural Language")
             with gr.Row():
                 with gr.Column(scale=1, min_width=450):
-                    gr.Markdown("### 🖌️ Create a Theme with Natural Language")
                     with gr.Group():
                         theme_prompt_input = gr.Textbox(label="Describe your theme", placeholder="Ex: a dark theme with purple tones...", lines=4)
                         theme_generate_button = gr.Button("Generate Theme ✨", variant="primary")
@@ -805,22 +981,21 @@ with gr.Blocks(css=css, title="GitRepo Inspector (MCP Server)") as app:
                         with gr.TabItem("Code to Use"):
                             python_code_output = gr.Code(label="Copy and paste", language="python")
                         with gr.TabItem("Publish to Hub"):
-                            gr.Markdown("Share your creation!")
                             hub_theme_name = gr.Textbox(label="Theme Name", placeholder="my-amazing-theme")
                             hub_hf_token = gr.Textbox(label="HF Token", type="password", placeholder="hf_...")
                             upload_button = gr.Button("Upload 🚀")
                             upload_status = gr.Markdown(visible=False)
-
-                chatbot_comp, msg_input_comp, add_msg_btn_comp = create_example_app()
+                chatbot_comp, msg_input_comp, add_msg_btn_comp = _create_example_app()
 
         with gr.TabItem("BONUS 2 - Sketch Image to Gradio UI"):
             gr.Markdown("### 🖼️ Create a UI from a Sketch")
+            gr.Markdown("*Note: This tool uses the Global API Key, but requires a Vision Model (selected below).*")
             with gr.Row():
-                llm_sketch_provider_dropdown = gr.Dropdown(choices=list(AVAILABLE_SKETCH_MODELS_BY_PROVIDER.keys()), value="sambanova", label="LLM Provider")
-                llm_sketch_model_dropdown = gr.Dropdown(
-                    choices=AVAILABLE_SKETCH_MODELS_BY_PROVIDER["sambanova"],
-                    value=AVAILABLE_SKETCH_MODELS_BY_PROVIDER["sambanova"][0],
-                    label="Model",
+                # Specific dropdown for Vision models, updated by global provider change
+                sketch_model_dropdown = gr.Dropdown(
+                    choices=AVAILABLE_SKETCH_MODELS_BY_PROVIDER["gemini"],
+                    value=AVAILABLE_SKETCH_MODELS_BY_PROVIDER["gemini"][0],
+                    label="Vision Model (Specific to Sketch Tool)",
                     interactive=True,
                 )
             with gr.Row():
@@ -829,68 +1004,102 @@ with gr.Blocks(css=css, title="GitRepo Inspector (MCP Server)") as app:
                     text_desc_input = gr.Textbox(label="Additional Description (Optional)")
                     sketch_generate_button = gr.Button("1. Generate Code", variant="secondary")
                 with gr.Column(scale=2):
-                    sketch_code_output = gr.Code(label="Generated UI Code", language="python", lines=20)
+                    with gr.Tabs():
+                        with gr.TabItem("🐍 Python Code"):
+                            sketch_code_output = gr.Code(label="Generated UI Code", language="python", lines=20)
+                        with gr.TabItem("👀 Live Preview"):
+                            sketch_preview_output = gr.HTML(label="Gradio-Lite Preview")
 
-    # Events binding
-    # Tool 1: Sync Repo
-    sync_button.click(fn=sync_repository, inputs=[sync_repo_url, sync_github_token], outputs=[sync_status_output], api_name="sync_repository")
+    # --- EVENTS & LOGIC ---
 
-    # Tool 2: Issue Analyzer
-    def update_model_choices(provider):
-        """
-        Updates the model dropdown choices when the provider changes.
-        """
-        models = AVAILABLE_ISSUE_MODELS_BY_PROVIDER.get(provider, [])
-        return gr.update(choices=models, value=models[0] if models else None)
+    # Unified Model Updater: Updates BOTH the Text Model (Global) and Vision Model (Sketch) dropdowns
+    get_models_btn.click(
+        fn=get_available_models,
+        inputs=None,
+        outputs=[models_info_output],
+        api_name="get_available_models"
+    )
+    def update_all_model_choices(provider):
+        text_models = AVAILABLE_ISSUE_MODELS_BY_PROVIDER.get(provider, [])
+        vision_models = AVAILABLE_SKETCH_MODELS_BY_PROVIDER.get(provider, [])
+        return (
+            gr.update(choices=text_models, value=text_models[0] if text_models else None),
+            gr.update(choices=vision_models, value=vision_models[0] if vision_models else None)
+        )
 
-    llm_issue_provider_dropdown.change(
-        fn=update_model_choices,
-        inputs=[llm_issue_provider_dropdown],
-        outputs=[llm_issue_model_dropdown],
+    global_provider.change(
+        fn=update_all_model_choices,
+        inputs=[global_provider],
+        outputs=[global_model, sketch_model_dropdown], # Update both dropdowns
         show_api=False
     )
+
+    # Tool 1: Sync
+    sync_button.click(
+        fn=sync_repository, 
+        inputs=[sync_repo_url, global_github_token], 
+        outputs=[sync_status_output], 
+        api_name="sync_repository"
+    )
+
+    # Tool 2: Analyzer
     issue_analyze_button.click(
         fn=analyze_github_issue,
-        inputs=[issue_repo_url, issue_number_input, llm_issue_provider_dropdown, llm_issue_model_dropdown, issue_github_token],
+        inputs=[
+            issue_repo_url, issue_number_input, 
+            global_provider, global_model, 
+            global_github_token, global_api_key
+        ],
         outputs=[issue_report_output],
         api_name="analyze_github_issue",
     )
-    # Tool 3: Issue Duplicate Finder
-    dup_llm_provider.change(fn=update_model_choices,
-                            inputs=[dup_llm_provider],
-                            outputs=[dup_llm_model],
-                            show_api=False
-    )
+
+    # Tool 3: Duplicate Finder
     dup_find_button.click(
         fn=find_duplicate_issues,
-        inputs=[dup_repo_url, dup_issue_number, dup_llm_provider, dup_llm_model, dup_github_token],
+        inputs=[
+            dup_repo_url, dup_issue_number, 
+            global_provider, global_model, 
+            global_github_token, global_api_key
+        ],
         outputs=[dup_report_output],
         api_name="find_duplicate_issues",
     )
-    # Tool 4: Issue Prioritizer
-    prio_llm_provider.change(
-        fn=update_model_choices,
-        inputs=[prio_llm_provider],
-        outputs=[prio_llm_model],
-        show_api=False
-    )
+
+    # Tool 4: Prioritizer
     prio_run_button.click(
         fn=prioritize_open_issues,
-        inputs=[prio_repo_url, prio_llm_provider, prio_llm_model],
+        inputs=[
+            prio_repo_url, 
+            global_provider, global_model, 
+            global_api_key
+        ],
         outputs=[prio_report_output],
         api_name="prioritize_open_issues"
     )
 
-    # region BONUS 1: Theme Generator
-    llm_theme_provider_dropdown.change(
-        fn=update_model_choices,
-        inputs=[llm_theme_provider_dropdown],
-        outputs=[llm_theme_model_dropdown],
-        show_api=False
+    # Tool 5: Action Runner
+    action_button.click(
+        fn=reply_and_close_issue,
+        inputs=[
+            action_repo_url, 
+            action_issue_number, 
+            action_comment, 
+            action_close_checkbox, 
+            global_github_token
+        ],
+        outputs=[action_output],
+        api_name="reply_and_close_issue"
     )
+    
+    # Bonus 1: Theme Gen
     theme_generate_button.click(
         fn=generate_theme,
-        inputs=[theme_prompt_input, llm_theme_provider_dropdown, llm_theme_model_dropdown],
+        inputs=[
+            theme_prompt_input, 
+            global_provider, global_model, 
+            global_api_key
+        ],
         outputs=[generated_theme_state, python_code_output, status_output, css_data_transport],
     ).then(
         fn=None,
@@ -898,12 +1107,25 @@ with gr.Blocks(css=css, title="GitRepo Inspector (MCP Server)") as app:
         outputs=None,
         js="(css) => { const action = () => apply_gradio_theme(css); if (typeof apply_gradio_theme === 'function') { action(); } else { document.addEventListener('theme-helper-injected', action, { once: true }); } }",
     )
+    upload_button.click(fn=handle_upload, inputs=[generated_theme_state, hub_theme_name, hub_hf_token], outputs=[upload_status])
 
-    upload_button.click(fn=handle_upload,
-                        inputs=[generated_theme_state, hub_theme_name, hub_hf_token],
-                        outputs=[upload_status]
+    # Bonus 2: Sketch (Uses Global Provider & Key, but LOCAL Vision Model)
+    generate_event = sketch_generate_button.click(
+        fn=generate_ui_from_sketch,
+        inputs=[
+            sketch_input, text_desc_input, 
+            global_provider, sketch_model_dropdown, 
+            global_api_key
+        ],
+        outputs=[sketch_code_output],
+    )    
+    generate_event.success(
+        fn=_create_gradio_lite_html,
+        inputs=[sketch_code_output],
+        outputs=[sketch_preview_output],
+        show_api=False
     )
-
+    
     def add_message_to_chat(history, message):
         """
         A simple function to add a user message to the chat history
@@ -920,53 +1142,15 @@ with gr.Blocks(css=css, title="GitRepo Inspector (MCP Server)") as app:
         time.sleep(0.5)
         history.append({"role": "assistant", "content": "Thank you for your message!"})
         return history
-
-    add_msg_btn_comp.click(
-        fn=add_message_to_chat,
-        inputs=[chatbot_comp, msg_input_comp],
-        outputs=[chatbot_comp],
-        show_api=False
-        ).then(
-            fn=lambda: "",
-            outputs=[msg_input_comp],
-            show_api=False
-        )
-    # endregion
-
-    # region BONUS 2 : Sketch to UI
-    def update_sketch_model_choices(provider):
-        """
-        Updates the sketch-to-ui model dropdown choices when the provider changes.
-        """
-        models = AVAILABLE_SKETCH_MODELS_BY_PROVIDER.get(provider, [])
-        return gr.update(choices=models, value=models[0] if models else None)
-
-    llm_sketch_provider_dropdown.change(fn=update_sketch_model_choices, inputs=[llm_sketch_provider_dropdown], outputs=[llm_sketch_model_dropdown])
-
-    sketch_generate_button.click(
-        fn=generate_ui_from_sketch,
-        inputs=[sketch_input, text_desc_input, llm_sketch_provider_dropdown, llm_sketch_model_dropdown],
-        outputs=[sketch_code_output],
-    )
-    # endregion
-    app.load(
-        fn=initialize_database,
-        inputs=None,
-        outputs=None,
-        show_api=False
-    ).then(
-        fn=inject_theme_helper_js,
-        inputs=None,
-        outputs=[html_injector],
-        show_api=False
-    )
+    
+    # Chat Example Logic
+    add_msg_btn_comp.click(fn=add_message_to_chat, inputs=[chatbot_comp, msg_input_comp], outputs=[chatbot_comp], show_api=False).then(fn=lambda: "", outputs=[msg_input_comp], show_api=False)
+    
+    # Init
+    app.load(fn=initialize_database, inputs=None, outputs=None, show_api=False).then(fn=_inject_theme_helper_js, inputs=None, outputs=[html_injector], show_api=False)
 
 # endregion
 if __name__ == "__main__":
-    check_env()
-
+    _check_env()
     app.allowed_paths = ["."]
-    app.launch(
-        mcp_server=True,
-        server_port=7860,
-    )
+    app.launch(mcp_server=True, server_port=7860)

config/clients/{gemini.py → gemini_cli.py}

@@ -14,12 +14,13 @@ BASE_URL = os.getenv("GEMINI_BASE_URL", "https://generativelanguage.googleapis.c
 DEFAULT_TEXT_MODEL = "gemini-2.0-flash"  # Default text model
 VISION_MODEL = "gemini-2.5-flash-lite"  # Model with vision capability
 
-
-def _get_api_key() -> Optional[str]:
-    api_key = os.getenv(API_KEY_ENV_VAR)
-    if not api_key:
-        print("WARNING: GOOGLE_API_KEY environment variable not set.")
-    return api_key
+def _get_api_key(provided_key: Optional[str] = None) -> Optional[str]:
+    """
+    Returns the provided key if valid, otherwise falls back to the environment variable.
+    """
+    if provided_key and provided_key.strip():
+        return provided_key.strip()
+    return os.getenv(API_KEY_ENV_VAR)
 
 
 def _format_payload_for_gemini(messages: List[Dict], image: Optional[Image.Image] = None) -> Optional[Dict]:
@@ -86,13 +87,14 @@ def call_api(
     stream: bool = False,
     temperature: float = 0.7,
     max_tokens: int = 8192,
+    api_key: Optional[str] = None,
 ) -> Union[Iterator[str], str]:
     """
     Calls the Google Gemini REST API, supporting text and multimodal inputs, with streaming.
     """
-    api_key = _get_api_key()
-    if not api_key:
-        error_msg = "Error: Google API key not configured."
+    final_api_key = _get_api_key(api_key)
+    if not final_api_key:
+        error_msg = "Error: Authentication required. No API key provided and no server fallback found."
         return iter([error_msg]) if stream else error_msg
 
     # Choose the model based on the presence of an image
@@ -113,12 +115,22 @@ def call_api(
     payload["generationConfig"] = {"temperature": temperature, "maxOutputTokens": max_tokens}
 
     stream_param = "streamGenerateContent" if stream else "generateContent"
-    request_url = f"{BASE_URL}{model_id}:{stream_param}?key={api_key}"
+    request_url = f"{BASE_URL}{model_id}:{stream_param}?key={final_api_key}"
     headers = {"Content-Type": "application/json"}
 
     try:
         response = requests.post(request_url, headers=headers, json=payload, stream=stream, timeout=180)
-        response.raise_for_status()
+        if response.status_code != 200:
+            try:
+                error_details = response.json()
+                error_msg = error_details.get('error', {}).get('message', response.text)
+            except:
+                error_msg = response.text
+            
+            if response.status_code in [400, 401, 403]:
+                raise ValueError(f"Gemini Auth Error: {error_msg}")
+            else:
+                raise RuntimeError(f"Gemini API Error ({response.status_code}): {error_msg}")
 
         if stream:
             # Re-implementing the streaming logic
@@ -146,10 +158,7 @@ def call_api(
                 print(f"Gemini's response format unexpected. Full response: {data}")
                 return f"[BLOCKED OR EMPTY RESPONSE]\n{data}"
 
-    except requests.exceptions.HTTPError as e:
-        err_msg = f"API HTTP Error ({e.response.status_code}): {e.response.text[:500]}"
-        print(err_msg)
-        return f"Error: {err_msg}"
+    except requests.exceptions.RequestException as e:
+        raise ConnectionError(f"Connection to Gemini failed: {str(e)}")
     except Exception as e:
-        print("Unexpected error in call_gemini_api:")
-        return f"Error: {e}"
+        raise e

config/clients/nebius_cli.py

@@ -0,0 +1,86 @@
+import base64
+import os
+from io import BytesIO
+from typing import Dict, List, Optional
+
+from PIL import Image
+from openai import APIConnectionError, AuthenticationError, OpenAI, RateLimitError
+
+# Configuration
+API_KEY_ENV_VAR = "NEBIUS_API_KEY"
+BASE_URL = os.getenv("NEBIUS_BASE_URL", "https://api.studio.nebius.ai/v1/") 
+DEFAULT_TEXT_MODEL = "meta-llama/Meta-Llama-3.1-70B-Instruct"
+DEFAULT_VISION_MODEL = "meta-llama/Llama-3.2-11B-Vision-Instruct"
+
+def _get_api_key(provided_key: Optional[str] = None) -> Optional[str]:
+    """
+    Returns the provided key if valid, otherwise falls back to the environment variable.
+    """
+    if provided_key and provided_key.strip():
+        return provided_key.strip()
+    return os.getenv(API_KEY_ENV_VAR)
+
+def call_api(messages: List[Dict], model_name: Optional[str] = None, image: Optional[Image.Image] = None, api_key: Optional[str] = None, **kwargs):
+    """
+    Calls the Nebius AI Studio API (OpenAI-compatible).
+    """
+    # 1. Resolve API Key
+    final_api_key = _get_api_key(api_key)
+    
+    if not final_api_key:
+        return "Error: Authentication required. Please provide a Nebius API Key."
+
+    # 2. Initialize Client
+    try:
+        client = OpenAI(base_url=BASE_URL, api_key=final_api_key)
+    except Exception as e:
+        return f"Error: Failed to initialize Nebius client. {e}"
+
+    # 3. Prepare Messages
+    final_messages = []
+    
+    if image:
+        print("Making a VISION call to Nebius.")
+        buffered = BytesIO()
+        image.save(buffered, format="PNG")
+        image_base64 = base64.b64encode(buffered.getvalue()).decode("utf-8")
+        
+        user_text = "Analyze this image."
+        for msg in messages:
+            if msg["role"] == "user":
+                user_text = msg["content"]
+                break
+        
+        content = [
+            {"type": "text", "text": user_text},
+            {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{image_base64}"}}
+        ]
+        
+        for msg in messages:
+            if msg["role"] == "system":
+                final_messages.append(msg)
+                
+        final_messages.append({"role": "user", "content": content})
+        final_model = model_name or DEFAULT_VISION_MODEL
+    else:
+        print("Making a TEXT call to Nebius.")
+        final_messages = messages
+        final_model = model_name or DEFAULT_TEXT_MODEL
+
+    # 4. Call API
+    try:
+        print(f"Calling Nebius API with model: {final_model}")
+        completion = client.chat.completions.create(
+            model=final_model,
+            messages=final_messages,
+            **kwargs
+        )
+        return completion.choices[0].message.content
+    except AuthenticationError as e:
+        raise ValueError(f"Authentication Failed: {e.body.get('message', str(e)) if e.body else str(e)}")
+    except RateLimitError:
+        raise RuntimeError("Rate Limit Exceeded (429). Please try again later.")
+    except APIConnectionError:
+        raise ConnectionError("Failed to connect to API. Check your internet.")
+    except Exception as e:
+        raise RuntimeError(f"API Error: {str(e)}")

config/clients/openai_cli.py

@@ -0,0 +1,91 @@
+import base64
+import os
+from io import BytesIO
+from typing import Dict, List, Optional
+
+from PIL import Image
+from openai import APIConnectionError, AuthenticationError, OpenAI, RateLimitError
+
+# Configuration
+API_KEY_ENV_VAR = "OPENAI_API_KEY"
+DEFAULT_TEXT_MODEL = "gpt-4o-mini"
+DEFAULT_VISION_MODEL = "gpt-4o"
+
+def _get_api_key(provided_key: Optional[str] = None) -> Optional[str]:
+    """
+    Returns the provided key if valid, otherwise falls back to the environment variable.
+    """
+    if provided_key and provided_key.strip():
+        return provided_key.strip()
+    return os.getenv(API_KEY_ENV_VAR)
+
+def call_api(messages: List[Dict], model_name: Optional[str] = None, image: Optional[Image.Image] = None, api_key: Optional[str] = None, **kwargs):
+    """
+    Calls the OpenAI API (GPT models).
+    """
+    # 1. Resolve API Key
+    final_api_key = _get_api_key(api_key)
+    
+    if not final_api_key:
+        return "Error: Authentication required. Please provide an OpenAI API Key."
+
+    # 2. Initialize Client
+    try:
+        client = OpenAI(api_key=final_api_key)
+    except Exception as e:
+        return f"Error: Failed to initialize OpenAI client. {e}"
+
+    # 3. Prepare Messages & Payload
+    final_messages = []
+    
+    # Handle Vision (Multimodal)
+    if image:
+        print("Making a VISION call to OpenAI.")
+        buffered = BytesIO()
+        image.save(buffered, format="PNG")
+        image_base64 = base64.b64encode(buffered.getvalue()).decode("utf-8")
+        
+        # Extract user text from messages to combine with image
+        user_text = "Analyze this image."
+        for msg in messages:
+            if msg["role"] == "user":
+                user_text = msg["content"]
+                break
+        
+        # Format strictly for OpenAI Vision
+        content = [
+            {"type": "text", "text": user_text},
+            {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{image_base64}"}}
+        ]
+        
+        # Add system prompt if exists
+        for msg in messages:
+            if msg["role"] == "system":
+                final_messages.append(msg)
+                
+        final_messages.append({"role": "user", "content": content})
+        final_model = model_name or DEFAULT_VISION_MODEL
+
+    # Handle Text-Only
+    else:
+        print("Making a TEXT call to OpenAI.")
+        final_messages = messages
+        final_model = model_name or DEFAULT_TEXT_MODEL
+
+    # 4. Call API
+    try:
+        print(f"Calling OpenAI API with model: {final_model}")
+        completion = client.chat.completions.create(
+            model=final_model,
+            messages=final_messages,
+            **kwargs
+        )
+        return completion.choices[0].message.content
+    except AuthenticationError as e:
+        raise ValueError(f"Authentication Failed: {e.body.get('message', str(e)) if e.body else str(e)}")
+    except RateLimitError:
+        raise RuntimeError("Rate Limit Exceeded (429). Please try again later.")
+    except APIConnectionError:
+        raise ConnectionError("Failed to connect to API. Check your internet.")
+    except Exception as e:
+        raise RuntimeError(f"API Error: {str(e)}")

config/clients/{sambanova.py → sambanova_cli.py}

@@ -4,6 +4,7 @@ from io import BytesIO
 from typing import Dict, List, Optional
 
 from PIL import Image
+from openai import APIConnectionError, AuthenticationError, RateLimitError
 from sambanova import SambaNova
 
 
@@ -13,23 +14,29 @@ BASE_URL = os.getenv("SAMBANOVA_BASE_URL", "https://api.sambanova.ai/v1")
 DEFAULT_TEXT_MODEL = "Meta-Llama-3.1-8B-Instruct"
 DEFAULT_VISION_MODEL = "Llama-4-Maverick-17B-128E-Instruct"
 
-api_key = os.getenv(API_KEY_ENV_VAR)
-if not api_key:
-    print("WARNING: SAMBANOVA_API_KEY environment variable not set.")
-    client = None
-else:
-    client = SambaNova(
-        api_key=api_key,
-        base_url=BASE_URL,
-    )
-
+def _get_api_key(provided_key: Optional[str] = None) -> Optional[str]:
+    """
+    Returns the provided key if valid, otherwise falls back to the environment variable.
+    """
+    if provided_key and provided_key.strip():
+        return provided_key.strip()
+    return os.getenv(API_KEY_ENV_VAR)
 
-def call_api(messages: List[Dict], model_name: Optional[str] = None, image: Optional[Image.Image] = None, **kwargs):
+def call_api(messages: List[Dict], model_name: Optional[str] = None, image: Optional[Image.Image] = None, api_key: Optional[str] = None, **kwargs):
     """
     Calls the SambaNova API, handling text or vision requests.
     """
-    if client is None:
-        return "Error: SambaNova client not initialized. Check the API key."
+   
+    final_api_key = _get_api_key(api_key)
+    
+    if not final_api_key:
+        return "Error: Authentication required. Please provide a SambaNova API Key."
+
+    try:
+        # Initialize client with the resolved key
+        client = SambaNova(api_key=final_api_key, base_url=BASE_URL)
+    except Exception as e:
+        return f"Error: Failed to initialize SambaNova client. {e}"
 
     if image:
         print("Making a VISION call to SambaNova.")
@@ -54,7 +61,19 @@ def call_api(messages: List[Dict], model_name: Optional[str] = None, image: Opti
         final_model = model_name or DEFAULT_TEXT_MODEL
 
     # API Call
-    print(f"Calling SambaNova API with model: {final_model}")
-    completion = client.chat.completions.create(model=final_model, messages=final_messages, **kwargs)
-
-    return completion.choices[0].message.content
+    try:
+        print(f"Calling SambaNova API with model: {final_model}")
+        completion = client.chat.completions.create(
+            model=final_model,
+            messages=final_messages,
+            **kwargs
+        )
+        return completion.choices[0].message.content
+    except AuthenticationError as e:
+        raise ValueError(f"Authentication Failed: {e.body.get('message', str(e)) if e.body else str(e)}")
+    except RateLimitError:
+        raise RuntimeError("Rate Limit Exceeded (429). Please try again later.")
+    except APIConnectionError:
+        raise ConnectionError("Failed to connect to API. Check your internet.")
+    except Exception as e:
+        raise RuntimeError(f"API Error: {str(e)}")

config/constants.py

@@ -3,13 +3,29 @@ PROVIDER_LOGOS = {
     "gemini": "https://upload.wikimedia.org/wikipedia/commons/d/d9/Google_Gemini_logo_2025.svg",
     "sambanova": "https://sambanova.ai/hs-fs/hubfs/sn-new-gray-logo.png?width=220&height=92&name=sn-new-gray-logo.png",
     "modal": "https://modal.com/_app/immutable/assets/logotype.CAx-nu9G.svg",
+    "openai": "https://upload.wikimedia.org/wikipedia/commons/4/4d/OpenAI_Logo.svg",
+    "nebius": "https://mintcdn.com/nebius-723e8b65/jsgY7B_gdaTjMC6y/logo/Main-logo-TF-Light.svg?fit=max&auto=format&n=jsgY7B_gdaTjMC6y&q=85&s=48ceb3cd949e5160c884634bbaf1af59",
     "default": "https://www.gradio.app/_app/immutable/assets/gradio.CHB5adID.svg",
 }
 
-AVAILABLE_SKETCH_MODELS_BY_PROVIDER = {"gemini": ["gemini-2.5-flash-lite"], "sambanova": ["Llama-4-Maverick-17B-128E-Instruct"]}
+AVAILABLE_SKETCH_MODELS_BY_PROVIDER = {
+    "gemini": ["gemini-2.5-flash", "gemini-2.5-flash-lite"], 
+    "sambanova": ["Llama-4-Maverick-17B-128E-Instruct"],
+    "openai": ["gpt-4o-mini", "gpt-4o"],
+    "nebius": [ 
+        "Qwen/Qwen2.5-VL-72B-Instruct",         
+    ]
+}
 AVAILABLE_ISSUE_MODELS_BY_PROVIDER = {
     "gemini": ["gemini-2.0-flash"],
-    "sambanova": ["DeepSeek-R1", "DeepSeek-V3-0324", "DeepSeek-V3.1", "Meta-Llama-3.1-8B-Instruct", "Meta-Llama-3.3-70B-Instruct", "gpt-oss-120b"],
+    "sambanova": ["DeepSeek-R1", "DeepSeek-V3-0324", "DeepSeek-V3.1", "Meta-Llama-3.1-8B-Instruct", "Meta-Llama-3.3-70B-Instruct", "gpt-oss-120b"],     
+    "openai": ["gpt-4o-mini", "gpt-4o"],
+    "nebius": [
+        "deepseek-ai/DeepSeek-R1-0528",        
+        "meta-llama/Llama-3.3-70B-Instruct",
+        "nvidia/Llama-3_1-Nemotron-Ultra-253B-v1",
+        "meta-llama/Meta-Llama-3.1-8B-Instruct-fast"
+    ]
 }
 
 # Prompt template
@@ -38,7 +54,7 @@ ALLOWED_HUE_COLORS = [
     "stone",
 ]
 
-SYSTEM_PROMPT_THEME_GENERATOR = f"""
+SYSTEM_PROMPT_THEME_GENERATOR_EN = f"""
 You are a world-class UI/UX designer with a deep understanding of the Gradio theme system. Your task is to take a user's high-level concept and generate a COMPLETE, COHESIVE, and AESTHETICALLY PLEASING theme configuration in JSON.
 
 **Your Design Philosophy:**
@@ -63,90 +79,41 @@ You are a world-class UI/UX designer with a deep understanding of the Gradio the
 Analyze the user's high-level request. Follow all the rules. Respond ONLY with the raw JSON object.
 """
 
-SYSTEM_PROMPT_GEMINI_ = """
-You are a precise theme generation assistant for the Gradio Python library. Your only job is to translate a user's description into a valid JSON object.
-
-**Your Task:**
-Based on the user's prompt, generate a JSON object with two keys: `constructor_args` and `set_args`.
-
-**RULES FOR `constructor_args`:**
-- This section defines the BASE palettes and sizes.
-- `primary_hue`, `secondary_hue`, `neutral_hue`: Choose a single color name (e.g., "blue", "pink", "slate").
-- `spacing_size`, `radius_size`, `text_size`: Choose `sm`, `md`, or `lg`.
-- `font`, `font_mono`: MUST be a list of strings (e.g., `["Roboto", "sans-serif"]`).
-
-**RULES FOR `set_args` (VERY IMPORTANT):**
-- This section overrides specific component styles.
-- **FOR EVERY VISUAL CUSTOMIZATION, YOU MUST PROVIDE A PAIR OF VALUES: one for light mode and one for dark mode (`_dark` version).**
-- **Example:** If the user wants a white background, you MUST provide both:
-  - `"body_background_fill": "white"`
-  - `"body_background_fill_dark": "*neutral_950"` (or another suitable dark color)
-- **Example:** If the user wants a green "cancel" button, you MUST provide both:
-  - `"button_cancel_background_fill": "green"`
-  - `"button_cancel_background_fill_dark": "darkgreen"`
-- **Example:** If a value should be the same in both modes (like a specific border width), provide both:
-  - `"button_border_width": "2px"`
-  - `"button_border_width_dark": "2px"`
-- Use palette references like `*primary_500` whenever possible. Remember the valid range is 50-950.
-- If the user asks for a "gradient", use the CSS `linear-gradient()` syntax.
-
-**Final Instruction:** Do not explain. Do not use markdown. Respond ONLY with the raw JSON object. Analyze the user prompt carefully and apply the rules above to fill out `constructor_args` and `set_args`.
-"""
-
-SYSTEM_PROMPT_LAYOUT = """
-You are a Python code generation assistant specializing in the Gradio library. Your task is to generate ONLY the Python code for a `gr.Blocks` layout based on a user's description.
-
-**CRITICAL RULES:**
-1.  **Code Only:** Your entire response MUST be a valid Python code block and NOTHING else. Do not include explanations, installation instructions, or markdown formatting.
-2.  **Layout Only:** Generate ONLY the layout structure (`gr.Blocks`, `gr.Row`, `gr.Column`, `gr.Tabs`, `gr.TabItem`, `gr.Accordion`, etc.).
-3.  **Placeholders, Not Logic:** Do NOT invent functions, logic, or event listeners (`.click()`, `.change()`). Instead, place placeholder components (`gr.Button()`, `gr.Textbox()`, etc.) inside the layout.
-4.  **Use Comments for Guidance:** Add `# TODO:` comments to guide the user on where to add their components and logic.
-5.  **Keep it Simple:** The goal is to provide a clean, empty boilerplate/scaffold for the user to fill in.
-
-**Example User Prompt:** "Create a layout with a row. On the left, a column for inputs, and on the right, a column with two tabs for outputs."
-
-**Example PERFECT Response (Your entire output should look like this):**
-```python
-import gradio as gr
-
-with gr.Blocks() as demo:
-    with gr.Row():
-        with gr.Column(scale=1):
-            gr.Markdown("### Inputs")
-            # TODO: Add your input components here
-            input_slider = gr.Slider(label="Input Value")
-            submit_button = gr.Button("Submit")
-
-        with gr.Column(scale=2):
-            with gr.Tabs():
-                with gr.TabItem("Image Output"):
-                    # TODO: Add your image output component here
-                    output_image = gr.Image()
-                with gr.TabItem("Text Output"):
-                    # TODO: Add your text output component here
-                    output_text = gr.Textbox(label="Logs")
-
-    # TODO: Define your functions and connect event listeners here
-    # submit_button.click(...)
-
-demo.launch()
-Now, generate the layout code for the user's request.
-"""
-
-SYSTEM_PROMPT_SKETCH = (
+# SYSTEM_PROMPT_SKETCH_EN = (
+#     """
+# You are an expert Gradio UI developer. Your task is to analyze a sketch and generate simple, clean, single-line Python code for a `gradio.Blocks` UI.
+
+# **CRITICAL RULES:**
+# 1.  **CODE ONLY:** Respond with a valid Python code block and nothing else.
+# 2.  **NO EXTERNAL LIBRARIES:** Only use the `gradio` library.
+# 3.  **NO FUNCTIONS OR CLASSES:** Start directly with `import gradio as gr` then `with gr.Blocks() as demo:`.
+# 4.  **NO MULTI-LINE STRINGS:** This is very important. Do NOT use triple quotes (`"""
+#     "..."
+#     """` or `'''...'''`). Use single-line strings (`"..."`) and `\n` for newlines if necessary. For `gr.Markdown`, combine content into a single line. Example: `gr.Markdown("# Title\n- Point 1\n- Point 2")`.
+# 5.  **MODERN COMPONENTS:** NEVER use `gr.Box()`. Use `gr.Group()` instead.
+# 6.  **DATA INITIALIZATION:** For `gr.Dataframe`, use a list of lists.
+
+# Now, analyze the user's sketch and generate the code following ALL rules.
+# """
+# )
+SYSTEM_PROMPT_SKETCH_EN = (
     """
-You are an expert Gradio UI developer. Your task is to analyze a sketch and generate simple, clean, single-line Python code for a `gradio.Blocks` UI.
+You are an expert Gradio UI developer. Your task is to analyze a sketch and generate valid, well-formatted Python code for a `gradio.Blocks` UI.
 
 **CRITICAL RULES:**
 1.  **CODE ONLY:** Respond with a valid Python code block and nothing else.
 2.  **NO EXTERNAL LIBRARIES:** Only use the `gradio` library.
 3.  **NO FUNCTIONS OR CLASSES:** Start directly with `import gradio as gr` then `with gr.Blocks() as demo:`.
 4.  **NO `demo.launch()`:** Do NOT include the `demo.launch()` call.
-5.  **NO MULTI-LINE STRINGS:** This is very important. Do NOT use triple quotes (`"""
+5.  **FORMATTING:** 
+    - Use standard Python indentation (4 spaces).
+    - **DO NOT** put multiple statements on one line using semicolons (`;`). 
+    - Each component must be on its own line.
+6.  **STRINGS:** Do NOT use triple quotes (`"""
     "..."
-    """` or `'''...'''`). Use single-line strings (`"..."`) and `\n` for newlines if necessary. For `gr.Markdown`, combine content into a single line. Example: `gr.Markdown("# Title\n- Point 1\n- Point 2")`.
-6.  **MODERN COMPONENTS:** NEVER use `gr.Box()`. Use `gr.Group()` instead.
-7.  **DATA INITIALIZATION:** For `gr.Dataframe`, use a list of lists.
+    """` or `'''...'''`). Use single-line strings (`"..."`) and `\n` for newlines if necessary.
+7.  **MODERN COMPONENTS:** NEVER use `gr.Box()`. Use `gr.Group()` instead. NEVER use `gr.Date()`. Use `gr.Textbox()` instead.
+8.  **DATA INITIALIZATION:** For `gr.Dataframe`, use a list of lists.
 
 Now, analyze the user's sketch and generate the code following ALL rules.
 """

config/model_factory.py

@@ -5,15 +5,13 @@ It abstracts the specific client implementations and provides a unified interfac
 """
 
 from typing import Any, Callable, Dict, List, Optional
-
 from PIL import Image
 
-
 # Step 1: Import the client-specific API call functions
 # It is assumed that there is a 'clients' directory with modules such as gemini.py, sambanova.py, etc.
 # Each module should expose a `call_api` function.
 try:
-    from .clients import gemini, sambanova
+    from .clients import gemini_cli, sambanova_cli, openai_cli, nebius_cli
 except ImportError:
     print("Warning: Could not import all LLM clients. Please ensure clients/gemini.py, clients/sambanova.py, etc. exist.")
 
@@ -22,14 +20,16 @@ except ImportError:
         def call_api(*args, **kwargs):
             return "Error: Client module not found."
 
-    gemini = sambanova = DummyClient()
+    gemini_cli = sambanova_cli = openai_cli = nebius_cli = DummyClient()
 
 
 # Step 2: Create a registry of available providers
 # This dictionary maps a provider name (string) to the function that calls its API.
 PROVIDER_REGISTRY: Dict[str, Callable] = {
-    "gemini": gemini.call_api,
-    "sambanova": sambanova.call_api,
+    "gemini": gemini_cli.call_api,
+    "sambanova": sambanova_cli.call_api,
+    "openai": openai_cli.call_api,
+    "nebius": nebius_cli.call_api,
     # To add a new provider, just add a new entry here, e.g.:
     # "another_provider": another_provider.call_api,
 }
@@ -62,7 +62,7 @@ class LLMFactory:
         return PROVIDER_REGISTRY[provider_key]
 
     @staticmethod
-    def call(llm_provider: str, llm_model: Optional[str] = None, messages: List[Dict] = [], image: Optional[Image.Image] = None, **kwargs: Any) -> str:
+    def call(llm_provider: str, llm_model: Optional[str] = None, messages: List[Dict] = [], image: Optional[Image.Image] = None, api_key: Optional[str] = None, **kwargs: Any) -> str:
         """
         The main factory method. It routes the request to the correct provider client.
         This method is designed to be the single point of contact for all LLM calls.
@@ -72,6 +72,7 @@ class LLMFactory:
             llm_model (Optional[str]): The specific model name to use (e.g., "gemini-1.5-pro-latest").
             messages (List[Dict]): A list of message dictionaries, following the standard role/content format.
             image (Optional[Image.Image]): A PIL Image object for multimodal (vision) requests.
+            api_key (Optional[str]): The API key for the provider. If not provided, it will try to use environment variables.
             **kwargs: Additional keyword arguments to pass to the provider's API call function
                       (e.g., temperature, max_tokens).
 
@@ -79,27 +80,21 @@ class LLMFactory:
             str: The text response from the LLM.
         """
         print(f"LLM Factory: Routing call to provider '{llm_provider}' with model '{llm_model or 'default'}'.")
+    
+        # Get the correct API function from the registry
+        api_call_function = LLMFactory.get_provider(llm_provider)
 
-        try:
-            # Get the correct API function from the registry
-            api_call_function = LLMFactory.get_provider(llm_provider)
-
-            # Prepare the arguments to be passed to the client function.
-            # Each client's `call_api` function is expected to handle these arguments.
-            api_kwargs = {"messages": messages, "model_name": llm_model, "image": image, **kwargs}
-
-            # Execute the API call
-            result = api_call_function(**api_kwargs)
+        # Prepare the arguments to be passed to the client function.
+        # Each client's `call_api` function is expected to handle these arguments.
+        api_kwargs = {"messages": messages, "model_name": llm_model, "image": image, "api_key": api_key, **kwargs}
 
-            if not isinstance(result, str):
-                print(f"Warning: LLM provider '{llm_provider}' returned a non-string result of type {type(result)}.")
-                return str(result)
+        # Execute the API call
+        result = api_call_function(**api_kwargs)
 
-            return result
+        if not isinstance(result, str):
+            print(f"Warning: LLM provider '{llm_provider}' returned a non-string result of type {type(result)}.")
+            return str(result)
 
-        except Exception:
-            import traceback
+        return result
 
-            traceback.print_exc()
-            # Return a standardized error string
-            return f"Error: Failed to get a response from the '{llm_provider}' provider."
+    

requirements.txt

@@ -1,7 +1,9 @@
 gradio
 gradio_htmlinjector
-dotenv
+python-dotenv
 requests
 sambanova
 markdown
-psycopg2-binary
+psycopg2-binary
+langchain-google-genai
+openai