Stabilize pro editing without heavy office runtime

The workspace now carries the pro editing flow, streaming completion path, and lighter Office preview state as one checkpoint so the remote has the current runnable project shape.

Constraint: Preserve the current workspace as a single reviewable project commit while excluding local agent state and verification artifacts. Removed stale Univer runtime dependencies from the lockfile so installs match package.json.

Rejected: Commit runtime screenshots, .omx state, and coverage files | they are local artifacts rather than source state.

Confidence: medium

Scope-risk: broad

Directive: Keep package.json and package-lock.json synchronized when changing frontend dependencies.

Tested: npm run build; C:\Users\ydy\.conda\envs\llmwebsite\python.exe -m pytest backend/tests/test_main_endpoints.py backend/tests/test_main_cancel.py backend/tests/test_llm.py backend/tests/test_llm_extended.py -v -o addopts= (44 passed).

Not-tested: Full pytest with repository coverage addopts currently reports 0% coverage because pytest-cov watches backend.* module names while tests import top-level backend modules.

Co-authored-by: OmX <omx@oh-my-codex.dev>

backend/main.py

@@ -1,5 +1,6 @@
 import asyncio
 import base64
+import json
 import logging
 import os
 import re
@@ -11,12 +12,12 @@ from typing import Optional
 
 from fastapi import FastAPI, HTTPException, Request, Security
 from fastapi.middleware.cors import CORSMiddleware
-from fastapi.responses import JSONResponse
+from fastapi.responses import JSONResponse, StreamingResponse
 from fastapi.security import APIKeyHeader
 from pydantic import BaseModel
 
 from geoip import get_ip_location_text
-from llm import call_ollama, call_vlm_ocr
+from llm import call_ollama, call_vlm_ocr, stream_ollama
 from models import UserPreferences
 from prompt import build_completion_prompts, prepare_prompt_context
 import markitdown
@@ -78,6 +79,8 @@ class CompletionRequest(BaseModel):
     model_thinking: str = "low"
     privacy_mode: bool = False
     user_preferences: Optional[UserPreferences] = None
+    model: Optional[str] = None
+    temperature: float = 0.7
 
 
 class CancelCompletionRequest(BaseModel):
@@ -143,6 +146,14 @@ def get_client_ip(request: Request) -> str:
     return request.headers.get("X-Client-IP") or "unknown"
 
 
+def _clamp_temperature(value: float, default: float = 0.7) -> float:
+    try:
+        numeric = float(value)
+    except (TypeError, ValueError):
+        return default
+    return max(0.0, min(numeric, 1.2))
+
+
 @app.post("/v1/completions")
 async def create_completion(request: Request, req: CompletionRequest, api_key: str = Security(get_api_key)):
     request_id = request.headers.get("X-Request-Id") or str(uuid.uuid4())
@@ -189,8 +200,9 @@ async def create_completion(request: Request, req: CompletionRequest, api_key: s
                 user_prompt,
                 system_prompt=system_prompt,
                 tag=f"{request_tag}-primary",
-                temperature=0.7,
+                temperature=_clamp_temperature(req.temperature, 0.7),
                 thinking=req.model_thinking if req.model_thinking != "none" else None,
+                model=req.model,
             )
         )
 
@@ -224,6 +236,124 @@ async def create_completion(request: Request, req: CompletionRequest, api_key: s
             ACTIVE_COMPLETIONS.pop(request_id, None)
 
 
+@app.post("/v1/pro/completions/stream")
+async def create_pro_completion_stream(request: Request, req: CompletionRequest, api_key: str = Security(get_api_key)):
+    request_id = request.headers.get("X-Request-Id") or str(uuid.uuid4())
+    request_tag = request_id[:8]
+    queue: asyncio.Queue[Optional[tuple[str, str]]] = asyncio.Queue()
+
+    client_ip = "hidden"
+    location = ""
+
+    if not req.privacy_mode:  # pragma: no cover
+        client_ip = get_client_ip(request)
+        location = get_ip_location_text(client_ip)
+        if location:
+            logger.info("[%s] client_location=%s", request_tag, location)
+
+    logger.info(
+        "[%s] /v1/pro/completions/stream request_id=%s client_ip=%s prefix_chars=%d suffix_chars=%d lang=%s thinking=%s privacy=%s model=%s temp=%.2f",
+        request_tag,
+        request_id,
+        client_ip,
+        len(req.prefix or ""),
+        len(req.suffix or ""),
+        req.languageId,
+        req.model_thinking,
+        req.privacy_mode,
+        req.model or "",
+        _clamp_temperature(req.temperature, 0.7),
+    )
+
+    llm_prefix, llm_suffix = prepare_prompt_context(req.prefix or "", req.suffix or "")
+    logger.info("[%s] pro_llm_input_prefix=%r", request_tag, llm_prefix)
+    logger.info("[%s] pro_llm_input_suffix=%r", request_tag, llm_suffix)
+
+    system_prompt, user_prompt = build_completion_prompts(
+        req.prefix,
+        req.suffix,
+        req.languageId,
+        location=location,
+        thinking_level=req.model_thinking,
+        preferences=req.user_preferences,
+    )
+
+    async def producer() -> None:
+        chunks: list[str] = []
+        try:
+            async for delta in stream_ollama(
+                user_prompt,
+                system_prompt=system_prompt,
+                tag=f"{request_tag}-pro",
+                temperature=_clamp_temperature(req.temperature, 0.7),
+                thinking=req.model_thinking if req.model_thinking != "none" else None,
+                model=req.model,
+                use_pro_model=True,
+            ):
+                chunks.append(delta)
+                await queue.put(("chunk", json.dumps({"delta": delta}, ensure_ascii=False)))
+
+            content = "".join(chunks)
+            logger.info(
+                "[%s] pro stream resolved request_id=%s content_chars=%d content_preview='%s'",
+                request_tag,
+                request_id,
+                len(content),
+                _preview(content, 120),
+            )
+            await queue.put((
+                "done",
+                json.dumps({"content": content, "request_id": request_id}, ensure_ascii=False),
+            ))
+        except asyncio.CancelledError:
+            logger.info("[%s] /v1/pro/completions/stream cancelled request_id=%s", request_tag, request_id)
+            await queue.put((
+                "cancelled",
+                json.dumps({"cancelled": True, "request_id": request_id}, ensure_ascii=False),
+            ))
+            raise
+        except Exception as e:
+            logger.exception("[%s] /v1/pro/completions/stream failed request_id=%s: %s", request_tag, request_id, e)
+            await queue.put((
+                "error",
+                json.dumps({"error": str(e), "request_id": request_id}, ensure_ascii=False),
+            ))
+        finally:
+            await queue.put(None)
+
+    producer_task = asyncio.create_task(producer())
+    existing = ACTIVE_COMPLETIONS.get(request_id)
+    if existing and not existing.done():
+        existing.cancel()
+    ACTIVE_COMPLETIONS[request_id] = producer_task
+
+    async def event_stream():
+        try:
+            while True:
+                item = await queue.get()
+                if item is None:
+                    break
+
+                event_name, data = item
+                yield f"event: {event_name}\ndata: {data}\n\n"
+        except asyncio.CancelledError:
+            producer_task.cancel()
+            raise
+        finally:
+            active = ACTIVE_COMPLETIONS.get(request_id)
+            if active is producer_task:
+                ACTIVE_COMPLETIONS.pop(request_id, None)
+
+    return StreamingResponse(
+        event_stream(),
+        media_type="text/event-stream",
+        headers={
+            "Cache-Control": "no-cache",
+            "X-Accel-Buffering": "no",
+        },
+    )
+
+
 @app.post("/v1/completions/cancel")
 async def cancel_completion(req: CancelCompletionRequest, api_key: str = Security(get_api_key)):
     request_tag = str(uuid.uuid4())[:8]
@@ -349,8 +479,19 @@ async def convert_to_markdown(request: ConvertRequest, api_key: str = Security(g
 
 # TTS and ASR routes (lazy loaded to avoid heavy import on startup)
 def _register_tts_asr_routes():
-    from tts_asr import register_tts_asr_routes
-    register_tts_asr_routes(app)
+    try:
+        from tts_asr import register_tts_asr_routes
+    except ModuleNotFoundError as exc:
+        logger.warning("Skipping TTS/ASR route registration because a dependency is missing: %s", exc)
+        return
+    except Exception as exc:
+        logger.warning("Skipping TTS/ASR route registration because import failed: %s", exc)
+        return
+
+    try:
+        register_tts_asr_routes(app)
+    except Exception as exc:
+        logger.warning("Failed to register TTS/ASR routes: %s", exc)
 
 _register_tts_asr_routes()