api fixed

README.md

@@ -21,7 +21,7 @@ Gradio demo with two tabs sharing one Bearer API key from the environment.
 | Tab | Gateway | Notes |
 |-----|---------|--------|
 | **Smart Doc** | `https://connect.zhihuiya.com/rd-llm/v1/documents/doc_parsing` | Multipart upload · `output_format=both` · **10 MB** max |
-| **Translation** | `https://connect.zhihuiya.com/hiro_translation` | `stream` (SSE segments) or `fast` (single JSON) |
+| **Translation** | `https://connect.zhihuiya.com/hiro_translation` | `stream`: SSE via `POST /translate`; `fast`: async submit + poll (`POST /translate/async` → `GET /translate/async/{taskId}`) |
 
 ## Auth
 

api_client.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import json
 import os
 import re
+import time
 from collections.abc import Iterator
 from pathlib import Path
 from typing import Any
@@ -20,6 +21,10 @@ API_KEY_ENV_FALLBACK = "RD_LLM_API_KEY"
 
 MAX_SMARTDOC_BYTES = 10 * 1024 * 1024
 
+# Async fast: submit + poll (aligned with hiro-translation-api).
+DEFAULT_POLL_INTERVAL_S = 1.5
+DEFAULT_POLL_TIMEOUT_S = 1800
+
 
 def resolve_api_key(api_key: str | None = None) -> str:
     """Prefer explicit key, then HIRO_API_KEY, then RD_LLM_API_KEY."""
@@ -38,18 +43,13 @@ def lang_to_codes(lang: str) -> tuple[str, str]:
     return src, tgt
 
 
-def translate_payload(
-    content: str,
-    lang: str,
-    *,
-    mode: str,
-) -> dict[str, Any]:
+def translate_payload(content: str, lang: str) -> dict[str, Any]:
+    """Request body for POST /translate and POST /translate/async (no mode field)."""
     source, target = lang_to_codes(lang)
     return {
         "content": content,
         "sourceLanguageCode": source,
         "targetLanguageCode": target,
-        "mode": mode,
     }
 
 
@@ -81,6 +81,16 @@ def _original_text(data: dict[str, Any], fallback: str = "") -> str:
     return value if isinstance(value, str) else fallback
 
 
+def _http_error_message(resp: requests.Response) -> str:
+    try:
+        body = resp.json()
+        if isinstance(body, dict):
+            return str(body.get("error") or body.get("message") or body)
+    except (json.JSONDecodeError, ValueError):
+        pass
+    return resp.text[:500]
+
+
 def health_ok(
     base_url: str = DEFAULT_BASE,
     *,
@@ -104,39 +114,189 @@ def health_ok(
         return False, str(exc)
 
 
-def translate_fast(
+def _gateway_error_message(data: Any, fallback: str = "") -> str | None:
+    """Extract connect-gateway style errors (error_msg / error_code)."""
+    if not isinstance(data, dict):
+        return None
+    if data.get("error_msg") or data.get("error_code") is not None:
+        msg = data.get("error_msg") or data.get("error") or "gateway error"
+        code = data.get("error_code")
+        if code is not None:
+            return f"[{code}] {msg}"
+        return str(msg)
+    if data.get("error"):
+        return str(data["error"])
+    if data.get("status") is False:
+        return fallback or str(data)
+    return None
+
+
+def submit_async_translate(
     text: str,
     lang: str,
     *,
     base_url: str = DEFAULT_BASE,
     api_key: str | None = None,
-    timeout: int = 1800,
+    timeout: int = 60,
 ) -> dict[str, Any]:
+    """POST /translate/async → {taskId, state}."""
     r = requests.post(
-        _api_url(base_url, "/translate"),
-        json=translate_payload(text, lang, mode="fast"),
+        _api_url(base_url, "/translate/async"),
+        json=translate_payload(text, lang),
         headers=_request_headers(api_key),
         timeout=timeout,
     )
     if r.status_code >= 400:
-        try:
-            err = r.json().get("error", r.text[:500])
-        except json.JSONDecodeError:
-            err = r.text[:500]
-        raise RuntimeError(err)
+        raise RuntimeError(_http_error_message(r))
+    try:
+        data = r.json()
+    except (json.JSONDecodeError, ValueError) as exc:
+        raise RuntimeError(f"invalid JSON from async submit: {r.text[:500]}") from exc
+
+    gateway_err = _gateway_error_message(data)
+    if gateway_err:
+        raise RuntimeError(gateway_err)
+
+    task_id = data.get("taskId")
+    if not task_id:
+        raise RuntimeError(f"missing taskId in submit response: {data}")
+    return {
+        "task_id": str(task_id),
+        "state": data.get("state", "pending"),
+        "billing_amount": r.headers.get("X-Openapi-Amount"),
+        "raw": data,
+    }
+
+
+def get_async_translate_result(
+    task_id: str,
+    *,
+    base_url: str = DEFAULT_BASE,
+    api_key: str | None = None,
+    timeout: int = 60,
+) -> dict[str, Any]:
+    """GET /translate/async/{taskId}."""
+    r = requests.get(
+        _api_url(base_url, f"/translate/async/{task_id}"),
+        headers=_request_headers(api_key, json_body=False),
+        timeout=timeout,
+    )
+    if r.status_code == 404:
+        raise RuntimeError(f"task not found: {_http_error_message(r)}")
+    if r.status_code >= 400:
+        raise RuntimeError(_http_error_message(r))
     data = r.json()
-    if data.get("state") not in (None, "success") and "error" in data:
-        raise RuntimeError(str(data.get("error", data)))
     return {
-        "state": data.get("state", "success"),
-        "text_original": _original_text(data, text),
+        "task_id": data.get("taskId", task_id),
+        "state": data.get("state"),
         "text_translated": _translated_text(data),
         "translated_character_count": data.get("translatedCharacterCount"),
+        "error": data.get("error"),
         "billing_amount": r.headers.get("X-Openapi-Amount"),
         "raw": data,
     }
 
 
+def iter_translate_fast(
+    text: str,
+    lang: str,
+    *,
+    base_url: str = DEFAULT_BASE,
+    api_key: str | None = None,
+    poll_interval_s: float = DEFAULT_POLL_INTERVAL_S,
+    poll_timeout_s: float = DEFAULT_POLL_TIMEOUT_S,
+) -> Iterator[dict[str, Any]]:
+    """Submit async fast translation and poll until succeeded/failed.
+
+    Yields status events, then a final event with ``done=True``.
+    """
+    submitted = submit_async_translate(text, lang, base_url=base_url, api_key=api_key)
+    task_id = submitted["task_id"]
+    yield {
+        "done": False,
+        "task_id": task_id,
+        "state": submitted.get("state", "pending"),
+        "phase": "submitted",
+    }
+
+    deadline = time.perf_counter() + poll_timeout_s
+    while True:
+        if time.perf_counter() > deadline:
+            raise RuntimeError(
+                f"async translation timed out after {poll_timeout_s:.0f}s "
+                f"(taskId={task_id})"
+            )
+        time.sleep(poll_interval_s)
+        result = get_async_translate_result(
+            task_id, base_url=base_url, api_key=api_key
+        )
+        state = result.get("state")
+        if state in ("succeeded", "failed"):
+            if state == "failed":
+                err = result.get("error") or "async translation failed"
+                raise RuntimeError(str(err))
+            translated = result.get("text_translated") or ""
+            if not str(translated).strip():
+                raise RuntimeError("empty translation from async result")
+            yield {
+                "done": True,
+                "task_id": task_id,
+                "state": "succeeded",
+                "phase": "done",
+                "text_original": text,
+                "text_translated": translated,
+                "translated_character_count": result.get(
+                    "translated_character_count"
+                ),
+                "billing_amount": result.get("billing_amount"),
+                "raw": result.get("raw"),
+            }
+            return
+        yield {
+            "done": False,
+            "task_id": task_id,
+            "state": state or "pending",
+            "phase": "polling",
+        }
+
+
+def translate_fast(
+    text: str,
+    lang: str,
+    *,
+    base_url: str = DEFAULT_BASE,
+    api_key: str | None = None,
+    poll_interval_s: float = DEFAULT_POLL_INTERVAL_S,
+    poll_timeout_s: float = DEFAULT_POLL_TIMEOUT_S,
+    timeout: int | None = None,
+) -> dict[str, Any]:
+    """Async fast translate: submit + poll until complete (blocking)."""
+    if timeout is not None:
+        poll_timeout_s = float(timeout)
+    final: dict[str, Any] | None = None
+    for event in iter_translate_fast(
+        text,
+        lang,
+        base_url=base_url,
+        api_key=api_key,
+        poll_interval_s=poll_interval_s,
+        poll_timeout_s=poll_timeout_s,
+    ):
+        if event.get("done"):
+            final = event
+    if final is None:
+        raise RuntimeError("async translation ended without a result")
+    return {
+        "state": "success",
+        "task_id": final.get("task_id"),
+        "text_original": final.get("text_original", text),
+        "text_translated": final.get("text_translated", ""),
+        "translated_character_count": final.get("translated_character_count"),
+        "billing_amount": final.get("billing_amount"),
+        "raw": final.get("raw"),
+    }
+
+
 def _iter_sse_json(resp: requests.Response) -> Iterator[dict[str, Any]]:
     for raw in resp.iter_lines(decode_unicode=True):
         if not raw:
@@ -169,19 +329,16 @@ def stream_translate(
     api_key: str | None = None,
     timeout: int = 1800,
 ) -> Iterator[dict[str, Any]]:
+    """POST /translate (stream-only; do not send mode)."""
     with requests.post(
         _api_url(base_url, "/translate"),
-        json=translate_payload(text, lang, mode="stream"),
+        json=translate_payload(text, lang),
         headers=_request_headers(api_key),
         stream=True,
         timeout=timeout,
     ) as resp:
         if resp.status_code >= 400:
-            try:
-                err = resp.json().get("error", resp.text[:500])
-            except (json.JSONDecodeError, ValueError):
-                err = resp.text[:500]
-            raise RuntimeError(err)
+            raise RuntimeError(_http_error_message(resp))
         yield from _iter_sse_json(resp)
 
 

app.py

@@ -26,11 +26,10 @@ import gradio as gr
 from api_client import (
     DEFAULT_BASE,
     SMARTDOC_URL,
-    health_ok,
     parse_document,
     resolve_api_key,
+    iter_translate_fast,
     stream_translate,
-    translate_fast,
 )
 
 CUSTOM_CSS = """
@@ -280,40 +279,6 @@ def _resolve_base(api_base: str) -> str:
     return (api_base or DEFAULT_BASE).strip().rstrip("/")
 
 
-def _has_health_endpoint(base: str) -> bool:
-    """Only the internal gateway exposes /health; the public connect gateway does not.
-
-    The public OpenAPI gateway (connect.zhihuiya.com) only routes the purchased
-    endpoints (e.g. /translate); probing /health there returns a permission/quota
-    error, not a real health signal.
-    """
-    return "/compute/hiro_translation_api" in base
-
-
-def check_service() -> str:
-    base = _resolve_base(DEFAULT_BASE)
-    key = resolve_api_key()
-    key_hint = "HIRO_API_KEY / RD_LLM_API_KEY" if not key else "API key loaded from env"
-
-    if not _has_health_endpoint(base):
-        return (
-            f'<span class="status-pill ok">● Public gateway<br>'
-            f'<span style="opacity:0.85">{html.escape(base)} · {html.escape(key_hint)}</span>'
-            f"</span>"
-        )
-
-    ok, msg = health_ok(base, api_key=key or None)
-    if ok:
-        return (
-            f'<span class="status-pill ok">● Online<br>'
-            f'<span style="opacity:0.85">{html.escape(base)} · {html.escape(key_hint)}</span></span>'
-        )
-    return (
-        f'<span class="status-pill err">● Unavailable<br>'
-        f'<span style="opacity:0.85">{html.escape(msg)}</span></span>'
-    )
-
-
 def _parse_progress(progress: str | None) -> tuple[int, int]:
     if not progress or "/" not in progress:
         return 0, 0
@@ -635,17 +600,39 @@ def run_translation(text: str, lang: str, mode: str):
 
     try:
         if mode == "fast":
-            data = translate_fast(text, lang, base_url=base, api_key=auth)
-            orig = data.get("text_original", text)
-            trans = data.get("text_translated", "")
-            elapsed = time.perf_counter() - t0
-            pairs = [(orig, trans)]
-            status = f"Done · fast mode · {elapsed:.1f}s"
-            out_chars = data.get("translated_character_count")
-            if out_chars is not None:
-                status += f" · {out_chars} chars"
-            yield emit(percent=100, status=status, force=True)
-            return
+            # Async fast: POST /translate/async then poll GET /translate/async/{taskId}
+            task_id = ""
+            for event in iter_translate_fast(text, lang, base_url=base, api_key=auth):
+                if not event.get("done"):
+                    task_id = str(event.get("task_id") or task_id)
+                    short = f"{task_id[:8]}…" if task_id else "…"
+                    state = event.get("state") or "pending"
+                    phase = event.get("phase") or "polling"
+                    elapsed = time.perf_counter() - t0
+                    if phase == "submitted":
+                        status = f"Submitted async task {short} · {elapsed:.1f}s"
+                        pct = 5.0
+                    else:
+                        status = f"Polling {short} · {state} · {elapsed:.1f}s"
+                        pct = min(90.0, 10.0 + elapsed)
+                    out = emit(percent=pct, status=status, force=True)
+                    if out is not None:
+                        yield out
+                    continue
+
+                orig = event.get("text_original", text)
+                trans = event.get("text_translated", "")
+                elapsed = time.perf_counter() - t0
+                pairs = [(orig, trans)]
+                status = f"Done · fast (async) · {elapsed:.1f}s"
+                out_chars = event.get("translated_character_count")
+                if out_chars is not None:
+                    status += f" · {out_chars} chars"
+                if task_id or event.get("task_id"):
+                    tid = str(event.get("task_id") or task_id)
+                    status += f" · task {tid[:8]}…"
+                yield emit(percent=100, status=status, force=True)
+                return
 
         for chunk in stream_translate(text, lang, base_url=base, api_key=auth):
             orig = chunk.get("text_original") or ""
@@ -751,18 +738,11 @@ def build_theme() -> gr.Theme:
 
 def build_ui() -> gr.Blocks:
     with gr.Blocks(
-        title="Document Processing",
+        title="Document Processing Demo",
         css=CUSTOM_CSS,
         theme=build_theme(),
     ) as demo:
-        with gr.Sidebar():
-            gr.HTML('<p class="main-title">Document Processing</p>')
-            gr.Markdown(
-                "Smart Doc + Translation · shared Bearer key from "
-                "`HIRO_API_KEY` (fallback `RD_LLM_API_KEY`)"
-            )
-            gateway_status = gr.HTML(value=check_service())
-            refresh_btn = gr.Button("Refresh status", size="sm", variant="secondary")
+        gr.HTML('<p class="main-title">Document Processing Demo</p>')
 
         with gr.Tabs():
             with gr.Tab("Smart Doc"):
@@ -833,7 +813,10 @@ def build_ui() -> gr.Blocks:
                         choices=["stream", "fast"],
                         value="stream",
                         label="Mode",
-                        info="stream: segment streaming; fast: single full response",
+                        info=(
+                            "stream: SSE segments via POST /translate; "
+                            "fast: async submit + poll via /translate/async"
+                        ),
                         scale=1,
                     )
                 lang = gr.Textbox(value="zh2en", visible=False)
@@ -884,8 +867,6 @@ def build_ui() -> gr.Blocks:
                         elem_id="hiro-stream-state",
                     )
 
-        refresh_btn.click(check_service, outputs=[gateway_status])
-
         def _combine_lang(src: str, tgt: str) -> str:
             return f"{src}2{tgt}"
 
@@ -961,11 +942,7 @@ def build_ui() -> gr.Blocks:
             outputs=[doc_file, smartdoc_status, smartdoc_md, smartdoc_json],
         )
 
-        demo.load(
-            check_service,
-            outputs=[gateway_status],
-            js=INIT_STREAM_WATCH_JS,
-        )
+        demo.load(fn=None, js=INIT_STREAM_WATCH_JS)
 
     return demo