'f1'

.gitignore

@@ -0,0 +1,223 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[codz]
+*$py.class
+
+# C extensions
+*.so
+.agents/
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#   Usually these files are written by a python script from a template
+#   before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py.cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+# Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+# uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+# poetry.lock
+# poetry.toml
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#   pdm recommends including project-wide configuration in pdm.toml, but excluding .pdm-python.
+#   https://pdm-project.org/en/latest/usage/project/#working-with-version-control
+# pdm.lock
+# pdm.toml
+.pdm-python
+.pdm-build/
+
+# pixi
+#   Similar to Pipfile.lock, it is generally recommended to include pixi.lock in version control.
+# pixi.lock
+#   Pixi creates a virtual environment in the .pixi directory, just like venv module creates one
+#   in the .venv directory. It is recommended not to include this directory in version control.
+.pixi
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# Redis
+*.rdb
+*.aof
+*.pid
+
+# RabbitMQ
+mnesia/
+rabbitmq/
+rabbitmq-data/
+
+# ActiveMQ
+activemq-data/
+
+# SageMath parsed files
+*.sage.py
+output/
+# Environments
+.env
+.envrc
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#   JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#   be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#   and can be added to the global gitignore or merged into this file.  For a more nuclear
+#   option (not recommended) you can uncomment the following to ignore the entire idea folder.
+# .idea/
+
+# Abstra
+#   Abstra is an AI-powered process automation framework.
+#   Ignore directories containing user credentials, local state, and settings.
+#   Learn more at https://abstra.io/docs
+.abstra/
+
+# Visual Studio Code
+#   Visual Studio Code specific template is maintained in a separate VisualStudioCode.gitignore 
+#   that can be found at https://github.com/github/gitignore/blob/main/Global/VisualStudioCode.gitignore
+#   and can be added to the global gitignore or merged into this file. However, if you prefer, 
+#   you could uncomment the following to ignore the entire vscode folder
+# .vscode/
+# Temporary file for partial code execution
+tempCodeRunnerFile.py
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+
+# Marimo
+marimo/_static/
+marimo/_lsp/
+__marimo__/
+
+# Streamlit
+.streamlit/secrets.toml
+
+cmd.txt
+chroma_db/
+local_docs/
+test.py

app.css

@@ -0,0 +1,299 @@
+body,
+.gradio-container {
+    background: #000000 !important;
+    color: #edf7ff !important;
+}
+
+.gradio-container {
+    min-height: 100vh !important;
+}
+
+#app-title {
+    padding: 22px 16px 12px !important;
+    text-align: center !important;
+}
+
+#app-title h1 {
+    color: #f3fbff !important;
+    font-size: 30px !important;
+    font-weight: 700 !important;
+    letter-spacing: 0.02em !important;
+    margin: 0 0 8px !important;
+}
+
+#app-title p {
+    color: #92aeca !important;
+    margin: 0 !important;
+}
+
+#title-divider-wrap {
+    max-width: 860px !important;
+    margin: -3px auto 12px !important;
+    padding: 0 16px !important;
+}
+
+#title-divider {
+    width: 100% !important;
+    height: 1px !important;
+    background: linear-gradient(
+        90deg,
+        rgba(255, 255, 255, 0) 0%,
+        rgba(255, 255, 255, 0.18) 22%,
+        rgba(255, 255, 255, 0.18) 78%,
+        rgba(255, 255, 255, 0) 100%
+    ) !important;
+}
+
+
+#chatbot,
+#chatbot > div,
+#chatbot .wrap,
+#chatbot .chatbot,
+#chatbot .bubble-wrap {
+    background: #000000 !important;
+    border: 0 !important;
+    box-shadow: none !important;
+}
+
+#chatbot {
+    max-width: 860px !important;
+    margin: 0 auto !important;
+    padding: 0 16px !important;
+}
+
+#chatbot .wrap,
+#chatbot .message,
+#chatbot .message-wrap,
+#chatbot .chatbot,
+#chatbot .prose,
+#chatbot .prose * {
+    /* Keep text bubble contents transparent to let bubble background show */
+}
+
+#chatbot .message,
+#chatbot .message-wrap {
+    border-radius: 22px !important;
+}
+
+#chatbot .message-wrap {
+    padding: 12px 0 !important;
+}
+
+/* 
+#chatbot .message.user,
+#chatbot .message.assistant,
+[data-testid="chatbot"] .message.user,
+[data-testid="chatbot"] .message.assistant {
+    width: fit-content !important; 
+    max-width: 85% !important;
+    flex-shrink: 0 !important;
+}
+
+#chatbot .message.user > div,
+#chatbot .message.user > p,
+#chatbot .message.user > span,
+#chatbot .message.user .prose,
+#chatbot .message.user .prose p {
+    width: max-content !important;
+    max-width: 100% !important;
+    white-space: pre-wrap !important;
+    word-break: break-word !important;
+} */
+
+/* #chatbot .message.assistant .prose,
+#chatbot .message.assistant .prose p {
+    width: auto !important;
+    white-space: pre-wrap !important;
+    word-break: break-word !important;
+    margin: 0 !important;
+} */
+
+
+
+#chatbot .message.bot,
+#chatbot .message.assistant {
+    color: #d6d6d6 !important;
+    padding: 14px 18px !important;
+}
+
+#chatbot textarea,
+#chatbot input {
+    background: rgba(8, 18, 29, 0.72) !important;
+    color: #f5fbff !important;
+    border: 1px solid rgba(120, 183, 224, 0.18) !important;
+}
+
+.chatbot button.copy-text,
+#chatbot button {
+    display: none !important;
+}
+
+#composer-row {
+    align-items: end !important;
+    background: rgba(7, 17, 28, 0.72) !important;
+    border: 1px solid rgba(120, 183, 224, 0.16) !important;
+    border-radius: 28px !important;
+    box-shadow: 0 16px 38px rgba(0, 0, 0, 0.28) !important;
+    gap: 8px !important;
+    margin: 12px auto 8px !important;
+    max-width: 860px !important;
+    padding: 10px 10px 10px 16px !important;
+    backdrop-filter: blur(18px);
+}
+
+#composer-row textarea {
+    background: transparent !important;
+    border: 0 !important;
+    box-shadow: none !important;
+    color: #f4fbff !important;
+    min-height: 44px !important;
+    padding: 10px 2px !important;
+}
+
+#composer-row textarea::placeholder {
+    color: #89a6c0 !important;
+}
+
+#composer-row label,
+#composer-row .wrap {
+    background: transparent !important;
+    border: 0 !important;
+    box-shadow: none !important;
+}
+
+#status-box {
+    color: #9db7cd !important;
+    font-size: 13px !important;
+    max-width: 860px !important;
+    margin: 0 auto !important;
+    min-height: 24px !important;
+    padding: 0 20px !important;
+}
+
+#send-arrow,
+#composer-row #send-arrow {
+    min-width: 42px !important;
+    max-width: 42px !important;
+    width: 42px !important;
+    height: 42px !important;
+    flex: 0 0 42px !important;
+    border-radius: 50% !important; 
+    padding: 0 !important;
+    margin: 0 0 2px !important;
+    background: linear-gradient(135deg, #2dd4bf 0%, #0d9488 100%) !important; 
+    color: #ffffff !important;
+    border: 0 !important;
+    box-shadow: 0 8px 20px rgba(13, 148, 136, 0.35) !important;
+    display: flex !important;
+    align-items: center !important;
+    justify-content: center !important;
+    cursor: pointer !important;
+    transition: all 0.2s ease !important;
+}
+
+
+#send-arrow:hover,
+#composer-row #send-arrow:hover {
+    background: linear-gradient(135deg, #34d399 0%, #059669 100%) !important;
+    transform: translateY(-1px) scale(1.04) !important;
+}
+
+#send-arrow *,
+#composer-row #send-arrow * {
+    color: #ffffff !important;
+    fill: #ffffff !important;
+}
+
+#settings-row {
+    gap: 10px !important;
+    margin: 12px auto 0 !important;
+    max-width: 860px !important;
+    padding: 0 16px !important;
+}
+
+#settings-row button {
+    background: rgba(7, 17, 28, 0.66) !important;
+    border: 1px solid rgba(120, 183, 224, 0.16) !important;
+    border-radius: 14px !important;
+    color: #d8f0ff !important;
+    backdrop-filter: blur(14px);
+}
+
+#model-panel,
+#upload-panel {
+    background: rgba(7, 17, 28, 0.72) !important;
+    border: 1px solid rgba(120, 183, 224, 0.16) !important;
+    border-radius: 18px !important;
+    margin: 10px auto 0 !important;
+    max-width: 828px !important;
+    padding: 14px !important;
+    backdrop-filter: blur(18px);
+}
+
+#model-panel label,
+#upload-panel label,
+#model-panel .wrap,
+#upload-panel .wrap {
+    background: transparent !important;
+    border-color: rgba(120, 183, 224, 0.14) !important;
+}
+
+#model-panel select,
+#model-panel input,
+#upload-panel input,
+#upload-panel textarea {
+    background: rgba(9, 20, 33, 0.78) !important;
+    color: #eff8ff !important;
+    border-color: rgba(120, 183, 224, 0.16) !important;
+}
+
+#upload-panel button {
+    background: rgba(10, 26, 41, 0.72) !important;
+    border: 1px solid rgba(120, 183, 224, 0.16) !important;
+    color: #d8f0ff !important;
+}
+
+#upload-panel button:hover,
+#settings-row button:hover {
+    border-color: rgba(92, 199, 255, 0.36) !important;
+}
+
+#composer-row .wrap,
+#settings-row .wrap {
+    box-shadow: none !important;
+}
+
+
+#chatbot .message.user,
+[data-testid="chatbot"] .message.user {
+    display: block !important;
+    width: fit-content !important; 
+    max-width: 85% !important;
+    padding: 8px 14px !important;
+    margin-left: auto !important; 
+    border-radius: 18px !important;
+    box-sizing: border-box !important;
+}
+
+#chatbot .message.user .message-wrap,
+#chatbot .message.user .prose {
+    display: block !important;
+    width: auto !important; 
+    max-width: 100% !important;
+    padding: 0 !important;
+    margin: 0 !important;
+    background: transparent !important;
+}
+#chatbot .message.user p,
+#chatbot .message.user .prose p,
+#chatbot .message.user > div {
+    display: inline-block !important; 
+    max-width: 100% !important;
+    white-space: pre-wrap !important;
+    word-break: normal !important;
+    overflow-wrap: break-word !important; 
+    color: #edf7ff !important;
+    margin: 0 !important;
+    padding: 0 !important;
+    line-height: 1.4 !important;
+}

app.py

@@ -0,0 +1,325 @@
+from __future__ import annotations
+
+import os
+import inspect
+import sys
+from pathlib import Path
+
+import gradio as gr
+from dotenv import load_dotenv
+from pypdf import PdfReader
+
+BASE_DIR = Path(__file__).resolve().parent
+PROJECT_ROOT = BASE_DIR.parent
+if str(PROJECT_ROOT) not in sys.path:
+    sys.path.insert(0, str(PROJECT_ROOT))
+
+from .router import build_model_route
+
+
+load_dotenv()
+
+PROXY_URL = os.environ.get("HTTP_PROXY") or None
+DEFAULT_PROVIDER = os.environ.get("DEFAULT_PROVIDER", "glm/4.7-flash")
+MAX_UPLOAD_CHARS = int(os.environ.get("MAX_UPLOAD_CHARS", "40000"))
+
+PROVIDER_CHOICES = [
+    ("GitHub Models · GPT-4.1 Mini", "github/gpt-4.1-mini"),
+    ("Gemini · 3.5 Flash", "gemini/3.5-flash"),
+    ("GLM · 4.7 Flash", "glm/4.7-flash"),
+]
+PROVIDER_OPTIONS = [value for _, value in PROVIDER_CHOICES]
+
+
+
+def _supports_kwarg(callable_obj: object, kwarg_name: str) -> bool:
+    try:
+        return kwarg_name in inspect.signature(callable_obj).parameters
+    except (TypeError, ValueError):
+        return False
+CHATBOT_USES_MESSAGES = _supports_kwarg(gr.Chatbot, "type")
+
+def _normalize_uploads(files: object | None) -> list[str]:
+    if not files:
+        return []
+
+    if isinstance(files, (str, Path)):
+        return [str(files)]
+
+    normalized: list[str] = []
+    for file_item in files if isinstance(files, list) else [files]:
+        if not file_item:
+            continue
+        if isinstance(file_item, (str, Path)):
+            normalized.append(str(file_item))
+            continue
+        file_path = getattr(file_item, "path", None) or getattr(file_item, "name", None)
+        if file_path:
+            normalized.append(str(file_path))
+    return normalized
+
+
+def _read_text_file(file_path: Path) -> str:
+    return file_path.read_text(encoding="utf-8", errors="ignore")
+
+
+def _read_pdf_file(file_path: Path) -> str:
+    reader = PdfReader(str(file_path))
+    pages: list[str] = []
+    for page in reader.pages:
+        text = page.extract_text() or ""
+        if text.strip():
+            pages.append(text)
+    return "\n\n".join(pages)
+
+
+def read_uploaded_context(uploaded_files: object | None) -> tuple[str, str]:
+    file_paths = _normalize_uploads(uploaded_files)
+    if not file_paths:
+        return "", "No uploads attached."
+
+    parts: list[str] = []
+    summary_lines = ["Uploaded context:"]
+
+    for file_path_str in file_paths:
+        file_path = Path(file_path_str)
+        summary_lines.append(f"- {file_path.name}")
+
+        try:
+            if file_path.suffix.lower() == ".pdf":
+                extracted = _read_pdf_file(file_path)
+            else:
+                extracted = _read_text_file(file_path)
+        except Exception as exc:
+            parts.append(f"[Could not read {file_path.name}: {exc}]")
+            continue
+
+        extracted = extracted.strip()
+        if not extracted:
+            parts.append(f"[No readable text found in {file_path.name}]")
+            continue
+
+        if len(extracted) > MAX_UPLOAD_CHARS:
+            extracted = extracted[:MAX_UPLOAD_CHARS] + "\n\n[Truncated for context limit.]"
+
+        parts.append(f"## {file_path.name}\n\n{extracted}")
+
+    return "\n\n".join(parts), "\n".join(summary_lines)
+
+
+def build_system_prompt(provider: str, model: str, upload_summary: str, uploaded_context: str) -> str:
+    base_prompt = (
+        "You are CodeAgent, a helpful assistant in a deployed web UI. "
+        "Local workspace tools, local file read/write, and RAG knowledge base tools are disabled in this deployment. "
+        "You can still help by reading user-uploaded text or PDF files, reasoning over that uploaded text, and generating markdown responses the user can download."
+    )
+
+    capability_note = (
+        f"\n\nCurrent model route: {provider}/{model}. "
+        "If the user asks for unavailable local tools, explain the limitation briefly and continue with the available uploaded context."
+    )
+
+    upload_note = f"\n\n{upload_summary}"
+    if uploaded_context.strip():
+        upload_note += f"\n\nUploaded content:\n{uploaded_context}"
+
+    return base_prompt + capability_note + upload_note
+
+
+
+
+def _format_chatbot_history(history: list[dict[str, str]]) -> object:
+    """Return chat history in the shape expected by the active Gradio Chatbot."""
+
+    return history
+
+
+def run_turn(
+    user_message: str,
+    history: list[dict[str, str]],
+    provider: str,
+    uploaded_files: object | None,
+    user_already_in_history: bool = False,
+) -> tuple[list[dict[str, str]], str, str]:
+    provider = (provider or DEFAULT_PROVIDER).strip().lower()
+    if provider not in PROVIDER_OPTIONS:
+        raise gr.Error(f"Unknown provider '{provider}'. Choose one of: {', '.join(PROVIDER_OPTIONS)}")
+    provider_name = provider.split("/")[0]
+    try:
+        route = build_model_route(provider_name=provider_name, proxy_url=PROXY_URL)
+    except Exception as exc:
+        raise gr.Error(str(exc)) from exc
+
+    uploaded_context, upload_summary = read_uploaded_context(uploaded_files)
+
+    system_prompt = build_system_prompt(provider, route.model, upload_summary, uploaded_context)
+    messages: list[dict[str, str]] = [{"role": "system", "content": system_prompt}]
+    messages.extend(history)
+    if not user_already_in_history:
+        messages.append({"role": "user", "content": user_message})
+
+    status = "Model is generating a markdown response. Local tools are disabled in this deployment."
+    if uploaded_context.strip():
+        status = "Model is generating a markdown response using uploaded text/PDF context. Local tools are disabled in this deployment."
+    response = route.client.chat.completions.create(
+        model=route.model,
+        messages=messages,
+    )
+    assistant_text = response.choices[0].message.content or ""
+    assistant_text = assistant_text.strip() or "The model returned an empty response."
+
+    updated_history = history + ([{"role": "user", "content": user_message}] if not user_already_in_history else []) + [
+        {"role": "assistant", "content": assistant_text},
+    ]
+
+    return updated_history, assistant_text, status
+
+
+def add_upload_summary(uploaded_files: object | None) -> str:
+    _, upload_summary = read_uploaded_context(uploaded_files)
+    return f"**Upload status**\n\n{upload_summary}"
+
+
+# Load CSS from file before creating Blocks
+APP_CSS = ""
+try:
+    with open(os.path.join(BASE_DIR, "app.css"), "r", encoding="utf-8") as file_handle:
+        APP_CSS = file_handle.read()
+except Exception:
+    pass
+
+blocks_kwargs = {"title": "CodeAgent Web UI"}
+launch_extra_kwargs = {}
+theme = gr.themes.Ocean()
+if _supports_kwarg(gr.Blocks.launch, "css"):
+    launch_extra_kwargs["css"] = APP_CSS
+else:
+    blocks_kwargs["css"] = APP_CSS
+if _supports_kwarg(gr.Blocks.launch, "theme"):
+    launch_extra_kwargs["theme"] = theme
+elif _supports_kwarg(gr.Blocks, "theme"):
+    blocks_kwargs["theme"] = theme
+
+with gr.Blocks(**blocks_kwargs) as demo:
+    gr.Markdown(
+        "<div id='app-title'>"
+        "<h1>CodeAgent</h1>"
+        "<p>AI assistant for research and analysis</p>"
+        "</div>",
+        elem_id="app-title",
+    )
+    gr.Markdown("<div id='title-divider'></div>", elem_id="title-divider-wrap")
+
+    chat_state = gr.State([])
+    model_panel_visible = gr.State(False)
+    upload_panel_visible = gr.State(False)
+    pending_user_message = gr.State("")
+
+    chatbot_kwargs = {"label": "Conversation", "height": 560, "show_label": False}
+    if CHATBOT_USES_MESSAGES:
+        chatbot_kwargs["type"] = "messages"
+    chatbot = gr.Chatbot(**chatbot_kwargs, elem_id="chatbot")
+
+    status_box = gr.Markdown("Ready. Send a message to start.", elem_id="status-box")
+
+    with gr.Row(scale=1, elem_id="composer-row"):
+        textbox_kwargs = {
+            "label": "Message",
+            "placeholder": "Message CodeAgent",
+            "lines": 1,
+            "scale": 8,
+            "show_label": False,
+            "container": False,
+        }
+        if _supports_kwarg(gr.Textbox, "submit_on_enter"):
+            textbox_kwargs["submit_on_enter"] = True
+        user_input = gr.Textbox(**textbox_kwargs)
+        send_btn = gr.Button("↑", elem_id="send-arrow")
+
+    with gr.Row(scale=1, elem_id="settings-row"):
+        toggle_model_btn = gr.Button("Model settings", scale=1)
+        toggle_upload_btn = gr.Button("Upload files", scale=1)
+
+    with gr.Column(visible=False, elem_id="model-panel") as model_panel:
+        provider = gr.Dropdown(
+            choices=PROVIDER_CHOICES,
+            value=DEFAULT_PROVIDER if DEFAULT_PROVIDER in PROVIDER_OPTIONS else PROVIDER_OPTIONS[0],
+            label="Model provider",
+            info="Choose where the request is sent",
+        )
+
+    with gr.Column(visible=False, elem_id="upload-panel") as upload_panel:
+        upload_box = gr.File(
+            label="Upload text or PDF",
+            file_count="multiple",
+            type="filepath",
+        )
+        upload_summary = gr.Markdown("**Upload status**\n\nNo uploads attached.")
+
+    upload_box.change(
+        fn=add_upload_summary,
+        inputs=[upload_box],
+        outputs=[upload_summary],
+    )
+
+    def toggle_model_panel(is_visible: bool):
+        new_visible = not is_visible
+        return new_visible, gr.update(visible=new_visible)
+
+    def toggle_upload_panel(is_visible: bool):
+        new_visible = not is_visible
+        return new_visible, gr.update(visible=new_visible)
+
+    toggle_model_btn.click(
+        fn=toggle_model_panel,
+        inputs=[model_panel_visible],
+        outputs=[model_panel_visible, model_panel],
+    )
+
+    toggle_upload_btn.click(
+        fn=toggle_upload_panel,
+        inputs=[upload_panel_visible],
+        outputs=[upload_panel_visible, upload_panel],
+    )
+    def handle_message(user_text: str, history: list[dict[str, str]], selected_provider: str, files: object | None):
+        if not user_text or not user_text.strip():
+            raise gr.Error("Please enter a message.")
+            
+        current_history = history or []
+        stripped_text = user_text.strip()
+        
+        updated_history = current_history + [{"role": "user", "content": stripped_text}]
+        yield updated_history, _format_chatbot_history(updated_history), "Model is generating a response...", ""
+        
+        final_history, assistant_text, status = run_turn(
+            stripped_text,
+            current_history,  
+            selected_provider,
+            files,
+            user_already_in_history=False,
+        )
+        
+        yield final_history, _format_chatbot_history(final_history), status, ""
+
+    send_btn.click(
+        fn=handle_message,
+        inputs=[user_input, chat_state, provider, upload_box],
+        outputs=[chat_state, chatbot, status_box, user_input],
+        show_progress="hidden"
+    )
+
+    user_input.submit(
+        fn=handle_message,
+        inputs=[user_input, chat_state, provider, upload_box],
+        outputs=[chat_state, chatbot, status_box, user_input],
+        show_progress="hidden"
+    )
+
+if __name__ == "__main__":
+    launch_kwargs = {
+        "server_name": "0.0.0.0",
+        "server_port": int(os.environ.get("PORT", "7862")),
+    }
+    launch_kwargs.update(launch_extra_kwargs)
+
+    demo.queue().launch(**launch_kwargs)

requirements.txt

@@ -0,0 +1,6 @@
+openai
+httpx
+requests
+python-dotenv
+pypdf
+gradio

router.py

@@ -0,0 +1,109 @@
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+from dotenv import load_dotenv
+import httpx
+from openai import OpenAI
+
+
+load_dotenv()
+
+
+@dataclass(frozen=True)
+class ModelRoute:
+    """OpenAI-compatible client plus the concrete model name to call."""
+
+    client: OpenAI
+    model: str
+    provider: str
+    base_url: str
+
+
+@dataclass(frozen=True)
+class ProviderConfig:
+    name: str
+    base_url: str
+    api_key_env: str
+    default_model: str
+
+
+PROVIDERS: dict[str, ProviderConfig] = {
+    "github": ProviderConfig(
+        name="github",
+        base_url="https://models.inference.ai.azure.com",
+        api_key_env="GITHUB_API_KEY",
+        default_model="gpt-4.1-mini",
+    ),
+    "openai": ProviderConfig(
+        name="openai",
+        base_url="https://api.openai.com/v1",
+        api_key_env="OPENAI_API_KEY",
+        default_model="gpt-4.1-mini",
+    ),
+    "gemini": ProviderConfig(
+        name="gemini",
+        base_url="https://generativelanguage.googleapis.com/v1beta/openai/",
+        api_key_env="GEMINI_API_KEY",
+        default_model="gemini-3.5-flash",
+    ),
+    "glm": ProviderConfig(
+        name="glm",
+        base_url="https://api.z.ai/api/paas/v4/",
+        api_key_env="GLM_API_KEY",
+        default_model="glm-4.7-flash",
+    ),
+}
+
+
+def _normalize(value: str | None) -> str:
+    return (value or "").strip().lower()
+
+
+def resolve_model(provider_name: str | None = None) -> tuple[ProviderConfig, str]:
+    """Resolve a friendly model/provider name into a provider config and model id."""
+
+    normalized_provider = _normalize(provider_name)
+
+    if normalized_provider:
+        if normalized_provider not in PROVIDERS:
+            known = ", ".join(sorted(PROVIDERS))
+            raise ValueError(f"Unknown provider '{provider_name}'. Known providers: {known}")
+        provider = PROVIDERS[normalized_provider]
+        return provider, provider.default_model
+
+
+    provider = PROVIDERS["github"]
+    return provider, provider.default_model
+
+
+def build_model_route(
+    provider_name: str | None = None,
+    proxy_url: str | None = None,
+) -> ModelRoute:
+    """Create the chat-completions client and model id for inference."""
+
+    provider, model = resolve_model(provider_name)
+    selected_base_url = provider.base_url.strip()
+    selected_api_key = os.environ.get(provider.api_key_env)
+    
+
+    if not selected_api_key:
+        raise ValueError(
+            f"Missing API key for provider '{provider.name}'. Set {provider.api_key_env}, "
+            "MODEL_API_KEY, API_TOKEN, or pass --api-key."
+        )
+
+    http_client = httpx.Client(proxy=proxy_url) if proxy_url else None
+    client = OpenAI(
+        base_url=selected_base_url,
+        api_key=selected_api_key,
+        http_client=http_client,
+    )
+
+    return ModelRoute(
+        client=client,
+        model=model,
+        provider=provider.name,
+        base_url=selected_base_url,
+    )