@oneciel-ai/ciel-runtime 0.2.2 → 0.2.4

package/scripts/colab/bootstrap_qwen_asr.py

@@ -0,0 +1,106 @@
+"""Bootstrap Qwen3-ASR on a Colab T4 and publish it only to the tailnet.
+
+Required Colab Secret: TAILSCALE_AUTHKEY
+Optional Colab Secret: CIEL_SPEECH_API_KEY
+"""
+
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+import shutil
+import subprocess
+import sys
+import time
+import urllib.request
+
+
+HOSTNAME = os.environ.get("CIEL_ASR_HOSTNAME", "ciel-asr")
+PORT = 8000
+SOCKET = "/tmp/ciel-asr-tailscaled.sock"
+STATE = "/tmp/ciel-asr-tailscaled.state"
+LOG_DIR = Path("/content/ciel-speech-logs")
+
+
+def secret(name: str, *, required: bool = False) -> str:
+    value = str(os.environ.get(name) or "").strip()
+    if not value:
+        try:
+            from google.colab import userdata  # type: ignore
+
+            value = str(userdata.get(name) or "").strip()
+        except Exception:
+            value = ""
+    if required and not value:
+        raise RuntimeError(f"Add {name} to Colab Secrets and allow notebook access, then rerun this script.")
+    return value
+
+
+def run(*args: str, check: bool = True) -> subprocess.CompletedProcess[str]:
+    print("+", " ".join(args))
+    return subprocess.run(args, check=check, text=True, capture_output=False)
+
+
+def install_tailscale() -> None:
+    if shutil.which("tailscale"):
+        return
+    run("bash", "-lc", "curl -fsSL https://tailscale.com/install.sh | sh")
+
+
+def start_tailscale(auth_key: str) -> tuple[str, str]:
+    install_tailscale()
+    LOG_DIR.mkdir(parents=True, exist_ok=True)
+    tail_log = (LOG_DIR / "tailscale-asr.log").open("ab")
+    subprocess.Popen(
+        ["tailscaled", f"--socket={SOCKET}", f"--state={STATE}", "--tun=userspace-networking"],
+        stdout=tail_log,
+        stderr=subprocess.STDOUT,
+        start_new_session=True,
+    )
+    for _ in range(60):
+        if Path(SOCKET).exists():
+            break
+        time.sleep(1)
+    run("tailscale", f"--socket={SOCKET}", "up", f"--auth-key={auth_key}", f"--hostname={HOSTNAME}", "--accept-dns=true", "--reset")
+    status = subprocess.check_output(["tailscale", f"--socket={SOCKET}", "status", "--json"], text=True)
+    dns_name = str(json.loads(status).get("Self", {}).get("DNSName") or HOSTNAME).rstrip(".")
+    serve = run("tailscale", f"--socket={SOCKET}", "serve", "--bg", "--https=443", f"http://127.0.0.1:{PORT}", check=False)
+    if serve.returncode == 0:
+        return dns_name, f"https://{dns_name}"
+    run("tailscale", f"--socket={SOCKET}", "serve", "--bg", "--http=80", f"http://127.0.0.1:{PORT}")
+    return dns_name, f"http://{dns_name}"
+
+
+def wait_for_server(api_key: str) -> None:
+    headers = {"authorization": f"Bearer {api_key}"} if api_key else {}
+    for _ in range(180):
+        try:
+            with urllib.request.urlopen(urllib.request.Request(f"http://127.0.0.1:{PORT}/health", headers=headers), timeout=3) as response:
+                if response.status < 500:
+                    return
+        except Exception:
+            time.sleep(2)
+    raise RuntimeError("Qwen ASR did not become healthy; inspect /content/ciel-speech-logs/qwen-asr.log")
+
+
+def main() -> None:
+    auth_key = secret("TAILSCALE_AUTHKEY", required=True)
+    api_key = secret("CIEL_SPEECH_API_KEY")
+    run(sys.executable, "-m", "pip", "install", "-U", "qwen-asr[vllm]", "vllm[audio]")
+    LOG_DIR.mkdir(parents=True, exist_ok=True)
+    command = [
+        "qwen-asr-serve", "Qwen/Qwen3-ASR-0.6B", "--host", "127.0.0.1", "--port", str(PORT),
+        "--gpu-memory-utilization", "0.78", "--max-model-len", "8192",
+    ]
+    if api_key:
+        command.extend(["--api-key", api_key])
+    server_log = (LOG_DIR / "qwen-asr.log").open("ab")
+    subprocess.Popen(command, stdout=server_log, stderr=subprocess.STDOUT, start_new_session=True)
+    wait_for_server(api_key)
+    dns_name, base_url = start_tailscale(auth_key)
+    print(json.dumps({"ok": True, "role": "asr", "hostname": dns_name, "base_url": base_url, "model": "Qwen/Qwen3-ASR-0.6B", "api_key_set": bool(api_key)}, indent=2))
+
+
+if __name__ == "__main__":
+    main()

package/scripts/configure_speech_workers.py

@@ -0,0 +1,37 @@
+"""Persist deployed speech worker URLs in the active Ciel Runtime config."""
+
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+import sys
+from typing import Any
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+
+
+def configure(asr_base_url: str, tts_base_url: str) -> dict[str, Any]:
+    import ciel_runtime
+
+    config = ciel_runtime.load_config()
+    speech = config.setdefault("speech", {})
+    asr = speech.setdefault("asr", {})
+    tts = speech.setdefault("tts", {})
+    asr.update({"enabled": True, "base_url": asr_base_url.rstrip("/"), "model": "Qwen/Qwen3-ASR-0.6B"})
+    tts.update({"enabled": True, "base_url": tts_base_url.rstrip("/"), "model": "OpenMOSS-Team/MOSS-TTS-Nano"})
+    ciel_runtime.save_config(config)
+    return {"asr": asr["base_url"], "tts": tts["base_url"]}
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--asr-base-url", required=True)
+    parser.add_argument("--tts-base-url", required=True)
+    args = parser.parse_args()
+    result = configure(args.asr_base_url, args.tts_base_url)
+    print(f"Configured Ciel speech workers: ASR={result['asr']} TTS={result['tts']}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/scripts/deploy_colab_speech.ps1

@@ -0,0 +1,47 @@
+param(
+    [string]$Distribution = "Ubuntu-26.04",
+    [string]$AsrSession = "ciel-asr",
+    [string]$TtsSession = "ciel-tts"
+)
+
+$ErrorActionPreference = "Stop"
+$repo = (Resolve-Path (Join-Path $PSScriptRoot "..")).Path
+$wslRepo = (& wsl -d $Distribution -- wslpath -a ($repo -replace '\\', '/')).Trim()
+if (-not $wslRepo) { throw "Could not resolve the repository path in WSL." }
+
+Write-Host "Checking Colab CLI authentication..."
+& wsl -d $Distribution -- bash -lc "colab status >/dev/null"
+if ($LASTEXITCODE -ne 0) {
+    throw "Colab CLI is not authenticated. Configure ADC in WSL (gcloud auth application-default login), then rerun."
+}
+
+Write-Host "Creating ASR T4 session: $AsrSession"
+& wsl -d $Distribution -- bash -lc "colab new --gpu T4 --session '$AsrSession'"
+if ($LASTEXITCODE -ne 0) { throw "Could not create ASR Colab session." }
+
+Write-Host "Creating TTS T4 session: $TtsSession"
+& wsl -d $Distribution -- bash -lc "colab new --gpu T4 --session '$TtsSession'"
+if ($LASTEXITCODE -ne 0) { throw "Could not create TTS Colab session." }
+
+Write-Host "Installing Qwen3-ASR and its Tailscale service..."
+$asrOutput = (& wsl -d $Distribution -- bash -lc "colab exec --session '$AsrSession' --file '$wslRepo/scripts/colab/bootstrap_qwen_asr.py'" 2>&1 | Tee-Object -Variable asrDisplay) -join "`n"
+if ($LASTEXITCODE -ne 0) { throw "ASR bootstrap failed." }
+
+Write-Host "Installing MOSS-TTS-Nano and its Tailscale service..."
+$ttsOutput = (& wsl -d $Distribution -- bash -lc "colab exec --session '$TtsSession' --file '$wslRepo/scripts/colab/bootstrap_moss_tts.py'" 2>&1 | Tee-Object -Variable ttsDisplay) -join "`n"
+if ($LASTEXITCODE -ne 0) { throw "TTS bootstrap failed." }
+
+function Read-BootstrapResult([string]$Text, [string]$Role) {
+    $matches = [regex]::Matches($Text, '(?s)\{\s*"ok"\s*:\s*true.*?\}')
+    if ($matches.Count -eq 0) { throw "Could not find the $Role bootstrap result in Colab output." }
+    $result = $matches[$matches.Count - 1].Value | ConvertFrom-Json
+    if ($result.role -ne $Role -or -not $result.base_url) { throw "Invalid $Role bootstrap result." }
+    return $result
+}
+
+$asr = Read-BootstrapResult $asrOutput "asr"
+$tts = Read-BootstrapResult $ttsOutput "tts"
+& python (Join-Path $PSScriptRoot "configure_speech_workers.py") --asr-base-url $asr.base_url --tts-base-url $tts.base_url
+if ($LASTEXITCODE -ne 0) { throw "Workers started, but Ciel speech configuration failed." }
+
+Write-Host "Both services are running and connected to Web Chat > Speech Settings."