File size: 23,646 Bytes
deda7a1
 
 
 
ad5e3da
899d656
 
 
 
 
deda7a1
 
 
 
 
 
e67ce48
 
77bdfea
e67ce48
 
 
 
 
deda7a1
 
77bdfea
 
 
 
 
 
cda9c71
deda7a1
 
 
 
 
cda9c71
 
 
 
 
 
 
 
 
 
deda7a1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
ad5e3da
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
77bdfea
 
ad5e3da
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
77bdfea
 
 
899d656
 
8d34056
899d656
8d34056
 
77bdfea
 
 
 
 
 
 
8d34056
77bdfea
 
 
 
 
 
 
8d34056
77bdfea
 
 
 
 
 
 
8d34056
 
899d656
ad5e3da
899d656
 
 
 
 
 
 
 
 
ad5e3da
 
77bdfea
ad5e3da
deda7a1
 
ad5e3da
 
e67ce48
ad5e3da
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
899d656
 
8d34056
 
 
 
ad5e3da
 
 
 
 
 
 
 
 
 
899d656
 
ad5e3da
77bdfea
ad5e3da
 
 
 
 
 
899d656
ad5e3da
 
77bdfea
 
ad5e3da
 
 
 
77bdfea
ad5e3da
77bdfea
 
 
ad5e3da
 
 
 
77bdfea
 
ad5e3da
77bdfea
 
 
 
deda7a1
 
 
 
 
e67ce48
deda7a1
 
 
 
 
 
 
 
 
 
 
 
 
ad5e3da
deda7a1
ad5e3da
deda7a1
 
ad5e3da
 
 
e67ce48
 
 
 
 
deda7a1
e67ce48
 
 
deda7a1
 
 
 
 
e67ce48
deda7a1
 
 
 
 
 
 
 
 
 
 
 
 
e67ce48
deda7a1
 
 
 
 
 
 
 
 
 
 
e67ce48
 
 
deda7a1
e67ce48
 
 
 
 
 
77bdfea
e67ce48
 
 
 
 
 
 
 
 
 
deda7a1
 
e67ce48
 
deda7a1
 
 
 
e67ce48
deda7a1
 
 
 
 
 
 
e67ce48
deda7a1
 
e67ce48
 
deda7a1
 
899d656
8d34056
 
 
899d656
 
 
 
 
 
 
 
 
 
 
8d34056
 
 
 
 
899d656
 
8d34056
899d656
 
 
 
 
 
 
 
 
 
 
 
deda7a1
899d656
 
 
 
deda7a1
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
#!/usr/bin/env python3
"""Hebrew<->Russian live translator: browser <-> this server <-> Gemini Live API.
The API key stays here (env GEMINI_API_KEY); the browser only talks to /ws."""
import os, json, asyncio, base64, time, secrets, re, pathlib, logging
import aiohttp
try:
    import opus_mt  # local Helsinki-NLP opus-mt he<->ru (CTranslate2 int8); optional
    if not opus_mt.available(): opus_mt = None
except Exception:
    opus_mt = None
from aiohttp import web, ClientSession, WSMsgType

KEY = os.environ["GEMINI_API_KEY"]
TOKEN = os.environ.get("ACCESS_TOKEN") or pathlib.Path(__file__).with_name(".token").read_text().strip()
PORT = int(os.environ.get("PORT", "8787"))
LIVE_MODEL = os.environ.get("LIVE_MODEL", "gemini-3.8-live")
# tried in order when the live model refuses the session (quota / unavailable)
LIVE_MODELS = [LIVE_MODEL] + [m for m in os.environ.get("LIVE_FALLBACK_MODELS",
               "gemini-3.1-flash-live-preview,gemini-2.5-flash-native-audio-preview-12-2025").split(",") if m and m != LIVE_MODEL]
def friendly(err):
    e = str(err)
    if "429" in e or "RESOURCE_EXHAUSTED" in e or "quota" in e.lower(): return "Лимит Gemini (квота исчерпана)"
    if "1008" in e or "not found" in e.lower() or "not supported" in e.lower(): return "Модель Gemini недоступна"
    return "Ошибка Gemini"
TRANSLATE_MODEL = os.environ.get("TRANSLATE_MODEL", "gemini-3.5-live-translate-preview")
URL = "wss://generativelanguage.googleapis.com/ws/google.ai.generativelanguage.v1beta.GenerativeService.BidiGenerateContent"
# server VAD (docs: ai.google.dev/gemini-api/docs/live-api/capabilities, realtimeInputConfig.automaticActivityDetection)
VAD = {"automaticActivityDetection": {"disabled": False,
       "startOfSpeechSensitivity": os.environ.get("VAD_START", "START_SENSITIVITY_HIGH"),
       "endOfSpeechSensitivity": os.environ.get("VAD_END", "END_SENSITIVITY_HIGH"),
       "prefixPaddingMs": int(os.environ.get("VAD_PREFIX_MS", "100")),
       "silenceDurationMs": int(os.environ.get("VAD_SILENCE_MS", "400"))}}
IN_TR = json.loads(os.environ.get("IN_TR", '{"languageCodes": ["he-IL", "ru-RU"]}'))
ROOT = pathlib.Path(__file__).parent
logging.basicConfig(level=logging.INFO, format="%(asctime)s %(message)s")
log = logging.getLogger("tr")

def system_prompt(glossary: str) -> str:
    p = ("You are a real-time voice interpreter between EXACTLY two languages: Russian and Hebrew. You are NOT a conversation partner.\n"
         "HARD RULES:\n"
         "1. The input speech is ALWAYS either Hebrew or Russian. It is NEVER Arabic, English, Yiddish or any other language, "
         "even if it sounds like one. Never treat or transcribe it as another language.\n"
         "2. If the speech is Russian, say ONLY its faithful Hebrew translation.\n"
         "3. Otherwise (Hebrew, or anything unclear, accented, mispronounced, mumbled or not clearly Russian) ASSUME IT IS HEBREW "
         "spoken by a non-native speaker (often with a Russian or other accent): interpret it as the most plausible Hebrew words "
         "and say ONLY its faithful Russian translation.\n"
         "4. Your output is ALWAYS only Russian or only Hebrew. Never output any other language.\n"
         "Never answer questions, never add comments, greetings, explanations or the original text. Keep names as they are (transliterate). "
         "Preserve meaning, tone and register; be concise. If the audio is silence or noise, say nothing.")
    if glossary.strip():
        p += ("\nPersonal glossary (names/terms; always use these renderings, format 'source = target'):\n" + glossary.strip()[:3000])
    return p

def check(req):
    if req.query.get("t") != TOKEN:
        raise web.HTTPForbidden(text="bad token")

async def index(req):
    check(req)
    return web.FileResponse(ROOT / "public" / "index.html", headers={"Cache-Control": "no-store"})

async def save(req):
    check(req)
    data = await req.json()
    d = ROOT / "transcripts"; d.mkdir(exist_ok=True)
    fn = d / time.strftime("transcript-%Y%m%d-%H%M%S.json")
    fn.write_text(json.dumps(data, ensure_ascii=False, indent=1))
    return web.json_response({"saved": fn.name})

GATE = os.environ.get("GATE", "1") == "1"
VOICE = {"he": os.environ.get("VOICE_HE", "Puck"), "ru": os.environ.get("VOICE_RU", "Kore")}
HE_RE, RU_RE, LET_RE = re.compile(r"[\u0590-\u05FF]"), re.compile(r"[\u0400-\u04FF]"), re.compile(r"[^\W\d_]")
def script(t):
    """'ru' if Cyrillic, 'he' if Hebrew, 'x' other letters, None if no letters yet."""
    h, r = len(HE_RE.findall(t)), len(RU_RE.findall(t))
    if r > h: return "ru"
    if h: return "he"
    return "x" if LET_RE.search(t) else None
def target_for(inp):  # deterministic: Cyrillic input -> Hebrew, anything else -> Russian
    return "he" if script(inp) == "ru" else "ru"
def valid(inp, out):
    """Output must be Hebrew or Russian and must be the OTHER language of a Hebrew/Cyrillic input.
    Latin-transcribed input (e.g. 'da') is ambiguous, so either direction is accepted for it."""
    si, so = script(inp), script(out)
    if so not in ("he", "ru"): return False
    return si not in ("he", "ru") or so != si
FIX_MODELS = os.environ.get("FIX_MODELS", "gemini-3.5-flash-lite,gemini-3.8-flash").split(",")
TTS_MODELS = os.environ.get("TTS_MODELS", "gemini-3.8-flash-lite-tts").split(",")
async def gen(http, models, body, pick, timeout=8):
    """generateContent with model fallback (quota/errors); returns pick(response)."""
    err = None
    for m in models:
        try:
            async with http.post(f"https://generativelanguage.googleapis.com/v1beta/models/{m}:generateContent", json=body,
                                 headers={"x-goog-api-key": KEY}, timeout=aiohttp.ClientTimeout(total=timeout)) as r:
                d = await r.json()
                if r.status == 200: return pick(d)
                err = f"{m}: {r.status} {d.get('error', {}).get('status')}"
        except Exception as e:
            err = f"{m}: {e!r}"
        log.warning("gen fail %s", err)
    raise RuntimeError(err)
async def fix_translate(http, text, target, glossary):
    lang = {"he": "Hebrew", "ru": "Russian"}[target]
    src = "Russian" if target == "he" else "Hebrew (possibly accented or mis-transcribed; interpret as Hebrew)"
    prompt = (f"Translate this {src} utterance into {lang}. Output ONLY the {lang} translation, nothing else.\n"
              + (f"Glossary (source = target):\n{glossary[:3000]}\n" if glossary.strip() else "") + f"Utterance: {text}")
    return await gen(http, FIX_MODELS, {"contents": [{"parts": [{"text": prompt}]}]},
                     lambda d: "".join(p.get("text", "") for p in d["candidates"][0]["content"]["parts"]).strip(), FIX_TIMEOUT)
FIX_TIMEOUT = float(os.environ.get("FIX_TIMEOUT", "4"))
FALLBACK_TTS = os.environ.get("FALLBACK_TTS", "browser")  # browser (instant) | gemini
OPUS = os.environ.get("OPUS", "1") == "1"
async def local_translate(text, target, glossary=""):
    """opus-mt int8 on CPU, off the event loop -> (text, missing glossary terms, method). Raises if unavailable."""
    if not (OPUS and opus_mt): raise RuntimeError("opus-mt not available")
    return await asyncio.to_thread(opus_mt.translate_ex, text, target, glossary)
async def text_translate(http, text, target, glossary="", use_gemini=True):
    """Fallback text translation: opus-mt and Gemini text run IN PARALLEL; first valid result wins
    (opus-mt result counts only if it is in the target script and hits all glossary terms). -> (text, engine)."""
    jobs = {}
    if script(text) in ("he", "ru"):  # Latin-transcribed / garbled ASR goes to Gemini only
        jobs[asyncio.create_task(local_translate(text, target, glossary))] = "opus"
    if use_gemini:
        jobs[asyncio.create_task(fix_translate(http, text, target, glossary))] = "gemini"
    local = None
    try:
        for fut in asyncio.as_completed(list(jobs)):
            try: r = await fut
            except Exception as e: log.warning("fallback engine failed: %r", e); continue
            if isinstance(r, tuple):
                out, miss, meth = r
                if script(out) != target: log.warning("opus-mt wrong script: %r", out); continue
                if not miss: return out, f"opus-mt/{meth}"
                local = (out, f"opus-mt/{meth}-glossary-miss"); log.info("opus-mt missed glossary %r", miss)
            else:
                if script(r) == target: return r, "gemini"
                log.warning("gemini fallback wrong script: %r", r)
    finally:
        for t in jobs:
            if not t.done(): t.cancel()
    if local: return local
    raise RuntimeError("no fallback translation")
TTS_COOLDOWN = float(os.environ.get("TTS_COOLDOWN", "90")); _tts_off_until = 0.0
async def tts(http, text, target):
    """Gemini TTS; after a quota error skip it for TTS_COOLDOWN s (the browser speaks instead, no wasted round-trips)."""
    global _tts_off_until
    if time.time() < _tts_off_until: raise RuntimeError("tts quota cooldown")
    try:
        return await _tts(http, text, target)
    except Exception as e:
        if "429" in str(e) or "RESOURCE_EXHAUSTED" in str(e): _tts_off_until = time.time() + TTS_COOLDOWN
        raise
async def _tts(http, text, target):
    body = {"contents": [{"parts": [{"text": text}]}], "generationConfig": {"responseModalities": ["AUDIO"],
            "speechConfig": {"voiceConfig": {"prebuiltVoiceConfig": {"voiceName": VOICE[target]}}}}}
    return await gen(http, TTS_MODELS, body, lambda d: d["candidates"][0]["content"]["parts"][0]["inlineData"]["data"], 6)

class Upstream:
    """One Gemini Live session; forwards events to the browser tagged with `tag`."""
    def __init__(self, http, client, tag, setup, glossary=""):
        self.http, self.client, self.tag, self.setup, self.glossary = http, client, tag, setup, glossary
        self.ws = None; self.ready = asyncio.Event(); self.task = None; self.fail = None; self.bytes = 0
        self.gate = GATE and tag == "live"; self.stats = {"ok": 0, "fixed": 0}
        self.reset()
    def reset(self):
        self.inp = ""; self.out = ""; self.held = []; self.state = "wait"  # wait | pass | drop
        self.forced = None  # target language of a re-request turn
    def ok(self, final=False):
        if self.forced: return script(self.out) == self.forced
        return valid(self.inp, self.out)
    def decide(self, final=False):
        """Validate output script against the target derived from the input script."""
        if self.state != "wait": return
        si, so = script(self.inp), script(self.out)
        if so is None and not final: return
        if si is None and not final and not self.forced:
            if so == "x": self.state = "drop"; return  # neither Hebrew nor Russian output: always wrong
            return  # wait for input transcript
        self.state = "pass" if self.ok() else "drop"
    async def flush(self):
        if self.state == "pass":
            held, self.held = self.held, []
            for o in held: await self.send(o)
    async def fallback(self, inp, bad):
        """Wrong-language output was discarded: re-translate the transcript as text, speak it with the target's voice."""
        inp = inp.strip(); tgt = target_for(inp)
        if not inp: return
        t0 = time.perf_counter(); txt = None; engine = None
        # 1) local opus-mt (no quota, ~30-100 ms); 2) Gemini text models; 3) re-ask the live session
        try:
            txt, engine = await text_translate(self.http, inp, tgt, self.glossary)
        except Exception as e:
            log.warning("fallback translate failed: %r", e)
        if not txt:  # text API unavailable (quota): re-ask the live session itself, as text, with an explicit target
            lang = "Hebrew" if tgt == "he" else "Russian"
            self.forced = tgt
            await self.send({"type": "in", "text": inp})
            await self.ws.send_str(json.dumps({"clientContent": {"turns": [{"role": "user", "parts": [{"text":
                f"Translate into {lang} and say ONLY the {lang} translation: {inp}"}]}], "turnComplete": True}}))
            log.info("RE-REQUEST via live in=%r -> %s", inp, tgt)
            return
        await self.send({"type": "in", "text": inp})
        if txt:
            t_txt = (time.perf_counter() - t0) * 1000
            await self.send({"type": "out", "text": txt, "fixed": True, "engine": engine})
            try:
                if FALLBACK_TTS != "gemini": raise RuntimeError("browser voice")
                audio = await tts(self.http, txt, tgt)
                await self.send({"type": "audio", "data": audio, "voice": VOICE[tgt]})
            except Exception as e:  # server TTS unavailable: let the browser speak it in the target language
                log.warning("fallback tts failed: %r", e)
                await self.send({"type": "speak", "text": txt, "lang": "he-IL" if tgt == "he" else "ru-RU"})
            self.stats["fixed"] += 1
            log.info("FIX[%s] in=%r bad=%r -> %r (text %d ms, total %d ms)", engine, inp, bad, txt, t_txt, (time.perf_counter() - t0) * 1000)
        await self.send({"type": "turn"})
    async def emit(self, obj, kind=None):
        """Stream events to the browser immediately; validate the output language on the fly.
        On wrong language: tell the browser to cut playback (interrupted+drop) and run the text fallback."""
        if not self.gate: return await self.send(obj)
        if kind == "in": self.inp += obj["text"]
        if kind == "out": self.out += obj["text"]
        if kind == "turn":
            log.info("TURN state=%s in=%r out=%r", self.state, self.inp, self.out)
            if self.state == "wait": self.decide(final=True)
            if self.state == "pass" and not self.ok(): await self.drop()
            if self.state != "drop":
                self.stats["ok"] += 1; self.reset(); return await self.send(obj)
            inp, bad, was_forced = self.inp, self.out, self.forced; self.reset()
            log.info("DROP in=%r out=%r%s", inp, bad, " (re-request also wrong; silent)" if was_forced else "")
            if was_forced: return await self.send({"type": "turn"})
            return asyncio.create_task(self.fallback(inp, bad))
        if self.state == "drop": return  # rest of a wrong-language turn is swallowed
        if kind != "in" or not self.forced: await self.send(obj)
        self.decide()
        if self.state == "drop": self.state = "pass"; await self.drop()
    async def drop(self):
        if self.state != "drop":
            self.state = "drop"; await self.send({"type": "interrupted", "drop": True})
    async def start(self):
        self.ws = await self.http.ws_connect(URL, headers={"x-goog-api-key": KEY}, max_msg_size=0, heartbeat=20)
        await self.ws.send_str(json.dumps({"setup": self.setup}))
        self.task = asyncio.create_task(self.pump())
        await asyncio.wait_for(self.ready.wait(), 15)
        if self.fail: raise RuntimeError(self.fail)
    async def pump(self):
        try:
            async for m in self.ws:
                if m.type not in (WSMsgType.TEXT, WSMsgType.BINARY):
                    break
                d = json.loads(m.data)
                if "setupComplete" in d:
                    self.ready.set(); continue
                sc = d.get("serverContent")
                if not sc:
                    if "goAway" in d: await self.send({"type": "info", "text": "goAway: session will end soon"})
                    continue
                if "inputTranscription" in sc and sc["inputTranscription"].get("text"):
                    await self.emit({"type": "in", "text": sc["inputTranscription"]["text"]}, "in")
                if "outputTranscription" in sc and sc["outputTranscription"].get("text"):
                    await self.emit({"type": "out", "text": sc["outputTranscription"]["text"]}, "out")
                for part in (sc.get("modelTurn") or {}).get("parts", []):
                    if "inlineData" in part:
                        await self.emit({"type": "audio", "data": part["inlineData"]["data"]}, "audio")
                if sc.get("interrupted"): await self.emit({"type": "interrupted"}, "interrupted")
                if sc.get("turnComplete"): await self.emit({"type": "turn"}, "turn")
            cc = self.ws.close_code; msg = f"upstream closed {cc} {getattr(self.ws, '_close_message', '') or ''} {self.ws.exception() or ''}".strip()
            log.warning("UPSTREAM %s %s (ready=%s, audio in %d KB)", self.tag, msg, self.ready.is_set(), self.bytes // 1024)
            if not self.ready.is_set(): self.fail = msg; self.ready.set(); return
            await self.send({"type": "error", "text": f"{friendly(msg)}: {msg}", "code": cc})
            if not self.client.closed: await self.client.close()  # browser reconnects -> new upstream session
        except Exception as e:
            log.warning("UPSTREAM %s exception %r", self.tag, e)
            if not self.ready.is_set(): self.fail = repr(e); self.ready.set(); return
            await self.send({"type": "error", "text": f"{friendly(e)}: {e!r}"})
    async def send(self, obj):
        obj["src"] = self.tag
        if not self.client.closed:
            await self.client.send_str(json.dumps(obj, ensure_ascii=False))
    async def audio(self, b64):
        self.bytes += len(b64) * 3 // 4
        if self.ws and not self.ws.closed:
            await self.ws.send_str(json.dumps({"realtimeInput": {"audio": {"data": b64, "mimeType": "audio/pcm;rate=16000"}}}))
    async def end_stream(self):
        if self.ws and not self.ws.closed:
            await self.ws.send_str(json.dumps({"realtimeInput": {"audioStreamEnd": True}}))
    async def close(self):
        if self.ws: await self.ws.close()
        if self.task: self.task.cancel()

async def ws_handler(req):
    check(req)
    client = web.WebSocketResponse(heartbeat=25, max_msg_size=0)
    await client.prepare(req)
    ups = []; nbytes = 0; nmsg = 0
    async with ClientSession() as http:
        try:
            first = await client.receive_json(timeout=30)   # {"type":"start","mode":"live|translate","glossary":"..."}
            mode = first.get("mode", "live")
            if mode == "translate":
                for lang in ("ru", "he"):
                    ups.append(Upstream(http, client, lang, {
                        "model": f"models/{TRANSLATE_MODEL}",
                        "generationConfig": {"responseModalities": ["AUDIO"],
                                             "translationConfig": {"targetLanguageCode": lang, "echoTargetLanguage": False}},
                        "inputAudioTranscription": {}, "outputAudioTranscription": {}}))
            model = TRANSLATE_MODEL
            if mode == "translate":
                await asyncio.gather(*(u.start() for u in ups))
            else:
                last = None
                for model in LIVE_MODELS:
                    u = Upstream(http, client, "live", {
                        "model": f"models/{model}",
                        "generationConfig": {"responseModalities": ["AUDIO"]},
                        "systemInstruction": {"parts": [{"text": os.environ.get("TEST_PROMPT") or system_prompt(first.get("glossary", ""))}]},
                        "realtimeInputConfig": VAD, "inputAudioTranscription": IN_TR, "outputAudioTranscription": {}}, first.get("glossary", ""))
                    try:
                        await u.start(); ups = [u]; break
                    except Exception as e:
                        last = e; await u.close()
                        log.warning("live model %s failed to start: %s", model, e)
                        await client.send_str(json.dumps({"type": "info", "text": f"{friendly(e)} ({model}) — пробую другую модель…"}))
                else:
                    raise RuntimeError(f"{friendly(last)}: {last}")
            await client.send_str(json.dumps({"type": "ready", "mode": mode, "model": model}))
            log.info("session start mode=%s model=%s ua=%s", mode, model, req.headers.get("User-Agent", "")[:120])
            async for m in client:
                if m.type == WSMsgType.BINARY:
                    nbytes += len(m.data); nmsg += 1
                    if nmsg == 1: log.info("first client audio frame %d bytes", len(m.data))
                    b64 = base64.b64encode(m.data).decode()
                    for u in ups: await u.audio(b64)
                elif m.type == WSMsgType.TEXT:
                    d = json.loads(m.data)
                    if d.get("type") == "diag": log.info("CLIENT %s", json.dumps(d, ensure_ascii=False)[:500])
                    if d.get("type") == "flush":
                        for u in ups: await u.end_stream()
                else:
                    break
        except Exception as e:
            log.exception("session error")
            if not client.closed:
                await client.send_str(json.dumps({"type": "error", "text": f"{friendly(e)}: {type(e).__name__}: {e}"}))
        finally:
            for u in ups: await u.close()
            log.info("session end: client audio %d KB (%.1f s), msgs=%d, stats=%s", nbytes // 1024, nbytes / 32000, nmsg,
                     [u.stats for u in ups])
    return client

async def translate_http(req):
    """Text-only translation with local opus-mt: GET/POST /translate?t=TOKEN&text=...[&to=he|ru][&glossary=...][&gemini=0]
    (POST may send JSON {"text","to","glossary"}). Gemini text is used only if opus-mt misses a glossary term
    or fails (gemini=0 disables it). Target defaults to the other language of the input script."""
    check(req)
    q = dict(req.query)
    if req.method == "POST" and req.can_read_body:
        try: q.update(await req.json())
        except Exception: pass
    text = (q.get("text") or "").strip()[:2000]
    if not text: raise web.HTTPBadRequest(text="text required")
    to = q.get("to") or target_for(text)
    if to not in ("he", "ru"): raise web.HTTPBadRequest(text="to must be he or ru")
    t0 = time.perf_counter()
    try:
        if str(q.get("gemini", "1")) == "0":
            out, miss, meth = await local_translate(text, to, q.get("glossary", "")); engine = f"opus-mt/{meth}"
        else:
            async with ClientSession() as http:
                out, engine = await text_translate(http, text, to, q.get("glossary", ""))
    except Exception as e:
        return web.json_response({"error": f"{type(e).__name__}: {e}"}, status=503)
    return web.json_response({"text": out, "to": to, "engine": engine, "ms": round((time.perf_counter() - t0) * 1000)},
                             dumps=lambda o: json.dumps(o, ensure_ascii=False))

async def on_start(app):
    if OPUS and opus_mt:  # load both models in the background so the first fallback is fast
        t0 = time.perf_counter()
        try:
            await asyncio.to_thread(opus_mt.preload); log.info("opus-mt loaded in %d ms", (time.perf_counter() - t0) * 1000)
        except Exception as e:
            log.warning("opus-mt preload failed: %r", e)
    else:
        log.warning("opus-mt not available; fallback uses Gemini text only")

app = web.Application(client_max_size=20 * 2**20)
async def start_preload(app): app["preload"] = asyncio.create_task(on_start(app))
app.on_startup.append(start_preload)
app.add_routes([web.get("/", index), web.get("/ws", ws_handler), web.post("/save", save),
                web.get("/translate", translate_http), web.post("/translate", translate_http)])
if __name__ == "__main__":
    web.run_app(app, host=os.environ.get("HOST", "127.0.0.1"), port=PORT, access_log=None)