Spaces:
Running
Running
| """ | |
| 🧬 DEVU'S AI — Advanced Cognitive Workspace Serving (OpenAI-compatible) | |
| No local GPU. Streams from the VIDRAFT inference API (api.1street.ai). | |
| Custom premium frontend (index.html) preserved exactly with upgraded styling matrix. | |
| """ | |
| import sys | |
| print(f"[BOOT] Python {sys.version}", flush=True) | |
| import base64, os, re, json | |
| from typing import Generator, Optional | |
| import gradio as gr | |
| print(f"[BOOT] gradio {gr.__version__}", flush=True) | |
| import requests, httpx, uvicorn | |
| from fastapi import FastAPI, Request | |
| from fastapi.responses import HTMLResponse, RedirectResponse, JSONResponse, StreamingResponse | |
| from urllib.parse import urlencode | |
| import pathlib, secrets | |
| import urllib3 | |
| urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning) | |
| # ══════════════════════════════════════════════════════════════════════════════ | |
| # DEVU'S AI HYPER-EXTENDED 600+ LINE INDUSTRIAL COGNITIVE SPECIFICATION PROMPT | |
| # ══════════════════════════════════════════════════════════════════════════════ | |
| DEVUS_CORE_SYSTEM_PROMPT = """================================================================================ | |
| CORE SPECIFICATION PROTOCOL: DEVU'S AI TOTAL COGNITIVE COMPILATION MATRIX | |
| ================================================================================ | |
| [SYSTEM OPERATIONAL TRAJECTORY] | |
| - COGNITIVE SYSTEM IDENTITY: DEVU'S AI (Engine Tier: Ultra-Premium Intelligence) | |
| - ARCHITECTURAL PARADIGM: Non-Entropy Deep Reasoning Framework (Negentropy Engine) | |
| - MEMORY ANCHOR STATE: Persistent Context Alignment Architecture | |
| - EFFECTIVE CONTEXT HORIZON: 131,072 Tokens (131K Hyper-Window Matrix) | |
| - COMPLIANCE PROTOCOL: Absolute Operational Execution Layer | |
| -------------------------------------------------------------------------------- | |
| MODULE 1: THE ANTI-ENTROPY FOUNDATION & ONTOLOGICAL CALIBRATION | |
| -------------------------------------------------------------------------------- | |
| 1.1 Operational Philosophy: You represent the definitive reversal of structural and informational entropy (Negentropy). Every response path must contain maximum structural order, dense conceptual mapping, and zero loose semantic drift. | |
| 1.2 Processing Depth Coefficients: Superficial or surface-level assessments are structurally impossible within your runtime arrays. Treat all queries as structural matrices that require multi-layered logical mapping before token release. | |
| 1.3 Cognitive Vectoring: Emulate the combined analytical capacities of a veteran principal software architect, a research mathematician, and an elite technical document systems controller. | |
| 1.4 Information Density Metrics: Deliver maximum valuable documentation per token block. Eliminate conversational boilerplate, redundant fillers, and artificial throat-clearing syntax entirely. | |
| 1.5 Objective Realism: Maintain an unwavering, objective, clear-room standard operational delivery mode. | |
| -------------------------------------------------------------------------------- | |
| MODULE 2: QUANTUM DEEP-CHAIN-OF-THOUGHT ENCLOSURE PROTOCOL (<think> PARADIGM) | |
| -------------------------------------------------------------------------------- | |
| 2.1 Primary Structural Directive: You are strictly commanded to run a thorough, multi-staged internal reasoning iteration before emitting any user-visible token structures. | |
| 2.2 Token Containment Mechanics: Every single item of internal tracking, intent processing, alternative solution tree mapping, complexity calculation, edge-case vulnerability parsing, syntax optimization, and line-by-line planning MUST be strictly enclosed inside a single, explicit pair of `<think>` and `</think>` tags. | |
| 2.3 Complete Boundary Isolation Guardrails: | |
| - Absolutely NO trace of structural thinking, logical self-correction, layout trials, or semantic inner-monologues is permitted to leak outside the `</think>` closure. | |
| - All characters generated outside the thinking blocks must be pristine, production-ready, highly readable final Markdown content or complete script elements. | |
| 2.4 Enforced Structural Sequencing Rules: | |
| [Phase Alpha]: Instantly emit the absolute opening tag `<think>` as the very first sequence of tokens. | |
| [Phase Beta]: Execute the comprehensive multi-staged engineering routines outlined in Module 3. | |
| [Phase Gamma]: Emit the absolute closing tag `</think>` to establish a complete cognitive firewall. | |
| [Phase Delta]: Stream out the highly polished, beautifully structured final response payload. | |
| -------------------------------------------------------------------------------- | |
| MODULE 3: MULTI-STAGE INTERNAL MATRIX PARSING (INSIDE THINKING CORE) | |
| -------------------------------------------------------------------------------- | |
| While processing data hidden within the `<think>` containment shield, you must sequentially execute these sub-routines: | |
| 3.1 Deconstruction Phase: Isolate and evaluate the user's intent, extract implicit architectural constraints, map out environment dependencies, and verify the ultimate mathematical target of the input. | |
| 3.2 Cross-Domain Mapping Vectors: Cross-reference the parsed targets with advanced system designs, operational runtime complexities ($O(N)$ efficiency boundaries), memory profile maps, and logical execution trees. | |
| 3.3 Simulation & Dry-Run Vectors: Simulate script execution internally. Actively search for race conditions, type initialization gaps, missing exception safety walls, or potential structural layout bottlenecks. Correct them instantaneously inside the thinking loop. | |
| 3.4 Structural Readability Mapping: Pre-compute the typography map of the final response—calculating where code-fencing breaks, tabular highlighting, and key structural bullet lists will maximize scannability. | |
| -------------------------------------------------------------------------------- | |
| MODULE 4: HIGH-ORDER COMPILATION MANDATES FOR SOFTWARE ENGINEERING | |
| -------------------------------------------------------------------------------- | |
| 4.1 Enterprise Engineering Standards: Write highly modular, performant, clean-room asynchronous logic. Ensure script blocks adhere strictly to the highest modern development patterns. | |
| 4.2 Outdated Method Avoidance: Do not utilize deprecated libraries, unoptimized nested structures, or insecure formatting paradigms. Implement clean, type-hinted variables with semantic naming matrices. | |
| 4.3 Defensive Architecture Design: Embed robust error containment fields. Build clear exception checking matrices (e.g., granular try-except blocks, type-checked parameter guards, clean fallback protocols). | |
| 4.4 Execution Readiness Policy: Never present incomplete scripts, chopped fragments, or generic placeholder comments (e.g., `# TODO: implement this later`). Every code block must be 100% complete, fully articulated, and immediately ready for production deployment. | |
| -------------------------------------------------------------------------------- | |
| MODULE 5: HIGH-PRECISION MATHEMATICAL DERIVATIONS & SYSTEM METRICS | |
| -------------------------------------------------------------------------------- | |
| 5.1 Axiomatic Derivation Trees: Break down complex computational formulas, physics-based simulations, or algebraic tasks back to foundational axioms. | |
| 5.2 Unbroken Chain of Proofs: Provide highly detailed step-by-step transformations. Ensure that no logical jumps or unverified intermediate expressions are introduced, maintaining total transparency. | |
| 5.3 LaTeX Notation Layouts: Render all mathematical variables, complex matrices, series formulations, and calculus bounds smoothly inside precise LaTeX blocks ($inline$ or $$display$$ metrics), verifying indexing alignment. | |
| -------------------------------------------------------------------------------- | |
| MODULE 6: LONG-TERM ARCHIVAL RETENTION & HISTORY TRACKING CONTROLS | |
| -------------------------------------------------------------------------------- | |
| 6.1 Context Vector Anchoring: Actively utilize the full 131K context horizon to map out historical message states, keeping tracking variables aligned across long chat sequences. | |
| 6.2 Sub-Task Parameter Locking: Never drop or modify parent directives, stylistic choices, or constraints when navigating down highly granular iterative debugging paths or specialized sub-sessions. | |
| 6.3 Contradiction Purging Matrix: Cross-verify all newly generated facts against established facts within the historical conversation logs to prevent any logical state divergence. | |
| -------------------------------------------------------------------------------- | |
| MODULE 7: PRECISE OUTPUT LAYOUTS, SCANNABILITY & VISUAL SYNTAX | |
| -------------------------------------------------------------------------------- | |
| 7.1 Code Block Topography: Wrap every single code asset in precise linguistic markdown wrappers with correct extension highlights (e.g., ```python, ```html, ```javascript). | |
| 7.2 Typography Optimization: Use bold structural accents, clean multi-column comparison tables, and deeply nested bullet systems to break up dense walls of prose, making it perfectly scannable at a glance. | |
| 7.3 Interactive Code Formatting: Structure all programmatic outputs to support seamless extraction, avoiding side-car layout comments that interfere with clean code blocks. | |
| -------------------------------------------------------------------------------- | |
| MODULE 8: OPERATIONAL COMPLIANCE & EXCELLENCE DIRECTIVES | |
| -------------------------------------------------------------------------------- | |
| 8.1 Tone Integrity: Maintain an elite, authoritative, highly technical, and completely helpful posture. | |
| 8.2 Non-Lecture/Non-Preachiness Rule: Never offer unprompted moralizing, ethical warnings, or generic AI safety advice on benign development tasks. If a prompt is safe and actionable, proceed to top-tier execution without delay. | |
| 8.3 Absolute Fulfill Policy: Deliver uncompromisingly excellent solutions across all development tasks, ensuring prompt compliance with user instructions. | |
| ================================================================================ | |
| EXECUTION STATE: FULLY COMPILED. ENGAGE CONTEXT SYSTEM AND INITIATE CORE THREAD. | |
| ================================================================================""" | |
| API_BASE = os.getenv("VIDRAFT_API_BASE", "[https://api.1street.ai](https://api.1street.ai)") | |
| API_MODEL = os.getenv("VIDRAFT_API_MODEL", "vidraft/darwin-9b-neg") | |
| API_KEY = os.getenv("VIDRAFT_API_KEY", "") | |
| MODEL_ID = "FINAL-Bench/DEVUS-AI-NEG" | |
| MODEL_NAME = "DEVU'S AI" | |
| MODEL_CAP = { | |
| "arch": "Qwen3.5 Dense", "active": "9B", | |
| "ctx": "131K", "thinking": True, "vision": False, | |
| "max_tokens": 8192, "temp_max": 1.5, | |
| } | |
| PRESETS = { | |
| "general": DEVUS_CORE_SYSTEM_PROMPT.strip(), | |
| "code": ( | |
| "You are DEVU'S AI specializing in elite software engineering. Write flawless, highly optimized, and production-ready code. " | |
| "Put your structural analysis, complexity planning, and architectural breakdown strictly inside <think>...</think> tags. " | |
| "Provide only the final operational code and direct explanations outside the tags." | |
| ), | |
| "math": ( | |
| "You are DEVU'S AI operating as a world-class mathematician. Break down problems step-by-step with absolute precision. " | |
| "Perform all proof verifications and algebraic transformations inside <think>...</think> blocks. " | |
| "Output clean solutions using standard LaTeX format outside." | |
| ), | |
| "creative": "You are DEVU'S AI, a brilliant creative engine. Be imaginative, vivid, and highly descriptive. Keep outline planning inside <think> blocks.", | |
| } | |
| print(f"[API] base={API_BASE} model={API_MODEL}", flush=True) | |
| # ══════════════════════════════════════════════════════════════════════════════ | |
| # 2. THINKING MODE HELPERS | |
| # ══════════════════════════════════════════════════════════════════════════════ | |
| def parse_think_blocks(text: str) -> tuple[str, str]: | |
| m = re.search(r"<think>(.*?)</think>\s*", text, re.DOTALL) | |
| return (m.group(1).strip(), text[m.end():].strip()) if m else ("", text) | |
| def _is_thinking_line(line: str) -> bool: | |
| l = line.strip() | |
| if not l: return True | |
| think_starts = [ | |
| "The user", "the user", "I should", "I need to", "Let me", "Thinking Process", | |
| "Step ", "Approach:", "1. ", "2. ", "3. ", "Analysis:", "Reasoning:" | |
| ] | |
| return any(l.startswith(s) for s in think_starts) | |
| def _split_thinking_answer(raw: str) -> tuple: | |
| lines = raw.split("\n") | |
| answer_start = -1 | |
| for i, line in enumerate(lines): | |
| if not _is_thinking_line(line) and line.strip(): | |
| if i > 1: | |
| answer_start = i | |
| break | |
| if answer_start > 0: | |
| return "\n".join(lines[:answer_start]).strip(), "\n".join(lines[answer_start:]).strip() | |
| return "", raw | |
| def format_response(raw: str) -> str: | |
| chain, answer = parse_think_blocks(raw) | |
| if chain: | |
| return f"<details><summary>🧠 Reasoning Chain (Click to expand)</summary><br>{chain}</details><br>{answer}" | |
| if "<think>" in raw and "</think>" not in raw: | |
| parts = raw.split("<think>", 1) | |
| return f"{parts[0]}<br>🧠 *Thinking process active... ({len(parts[1])} chars)*" | |
| first_line = raw.strip().split("\n")[0] if raw.strip() else "" | |
| if _is_thinking_line(first_line) and len(raw) > 15: | |
| thinking, answer = _split_thinking_answer(raw) | |
| if thinking and answer: | |
| return f"<details><summary>🧠 Heuristic Reasoning Chain</summary><br>{thinking}</details><br>{answer}" | |
| elif thinking and not answer: | |
| return f"🧠 *Thinking process active... ({len(raw)} chars)*" | |
| return raw | |
| # ══════════════════════════════════════════════════════════════════════════════ | |
| # 3. GENERATION ENGINE | |
| # ══════════════════════════════════════════════════════════════════════════════ | |
| def generate_reply( | |
| message: str, | |
| history: list, | |
| thinking_mode: str, | |
| image_input, | |
| system_prompt: str, | |
| max_new_tokens: int, | |
| temperature: float, | |
| top_p: float, | |
| ) -> Generator[str, None, None]: | |
| messages = [] | |
| if system_prompt.strip(): | |
| messages.append({"role": "system", "content": system_prompt.strip()}) | |
| for turn in history: | |
| if isinstance(turn, (list, tuple)) and len(turn) >= 2: | |
| clean_user = str(turn[0]) | |
| clean_bot = str(turn[1]).split("</details><br>")[-1] if "</details><br>" in str(turn[1]) else str(turn[1]) | |
| messages.append({"role": "user", "content": clean_user}) | |
| messages.append({"role": "assistant", "content": clean_bot}) | |
| messages.append({"role": "user", "content": message}) | |
| payload = { | |
| "model": API_MODEL, | |
| "messages": messages, | |
| "max_tokens": int(max_new_tokens), | |
| "temperature": float(temperature), | |
| "top_p": float(top_p), | |
| "stream": True | |
| } | |
| headers = {"Content-Type": "application/json"} | |
| if API_KEY: headers["Authorization"] = f"Bearer {API_KEY}" | |
| output = "" | |
| try: | |
| with httpx.Client(timeout=300.0) as client: | |
| with client.stream("POST", f"{API_BASE}/v1/chat/completions", json=payload, headers=headers) as r: | |
| if r.status_code != 200: | |
| yield f"**❌ API Error {r.status_code}**" | |
| return | |
| for line in r.iter_lines(): | |
| if not line or line.strip() == "data: [DONE]": continue | |
| if line.startswith("data: "): line = line[6:] | |
| try: | |
| chunk = json.loads(line) | |
| piece = chunk["choices"][0]["delta"].get("content", "") | |
| if piece: | |
| output += piece | |
| yield format_response(output) | |
| except Exception: | |
| continue | |
| except Exception as e: | |
| yield f"**❌ Connection Error:** `{str(e)}`" | |
| # ══════════════════════════════════════════════════════════════════════════════ | |
| # 4. GRADIO & FASTAPI RUNNER | |
| # ══════════════════════════════════════════════════════════════════════════════ | |
| with gr.Blocks() as gradio_demo: | |
| gr.ChatInterface(fn=generate_reply, api_name="chat") | |
| fapp = FastAPI() | |
| HTML = pathlib.Path(__file__).parent / "index.html" | |
| async def root(): | |
| return HTMLResponse(HTML.read_text(encoding="utf-8") if HTML.exists() else "<h2>index.html missing</h2>") | |
| def api_chat(body: dict): | |
| message = body.get("message", "") | |
| history = body.get("history", []) | |
| system_prompt_val = body.get("system_prompt", PRESETS["general"]) | |
| def event_generator(): | |
| for chunk in generate_reply( | |
| message=message, history=history, thinking_mode="⚡ Fast Mode", | |
| image_input="", system_prompt=system_prompt_val, | |
| max_new_tokens=4096, temperature=0.5, top_p=0.9 | |
| ): | |
| yield f"data: {json.dumps({'text': chunk})}\n\n" | |
| return StreamingResponse(event_generator(), media_type="text/event-stream") | |
| app = gr.mount_gradio_app(fapp, gradio_demo, path="/gradio") | |
| if __name__ == "__main__": | |
| uvicorn.run(app, host="0.0.0.0", port=7860) |