Revert repository state to e4b57c8

README.md

@@ -4,63 +4,76 @@ emoji: ⚡
 colorFrom: indigo
 colorTo: indigo
 sdk: gradio
-sdk_version: 5.42.0
+sdk_version: 6.6.0
 python_version: "3.12"
 app_file: app.py
 pinned: false
 license: mit
-short_description: Phase 1 ZeroGPU Parakeet transcription API
+short_description: Phase 1 rebuild scaffold - Parakeet-only transcription API
 ---
 
 # Phase 1 rebuild: Parakeet-only
 
-This repository is still using `plan/rebuild_plan.md` as the source of truth, but the active Phase 1 implementation now closely follows the working ZeroGPU reference Space:
+This repository has been reset for a phased rebuild using `plan/rebuild_plan.md` as the source of truth.
 
-- `rishiraj/parakeet-tdt-0.6b-v3`
+## Current scope
+Only Phase 1 is active:
+- Parakeet-only transcription API
+- CPU-side preload/probing/postprocessing
+- narrow `@spaces.GPU(duration=120)` window around inference only
 
-## Active scope
-- Parakeet-only transcription
-- ZeroGPU execution via `@spaces.GPU(duration=8)`
-- dependency set aligned with the working reference Space
-- minimal `/transcribe_parakeet` API route
-
-## Not implemented yet
+Not implemented yet:
 - pyannote diarization
-- transcript/diarization merge
+- merge logic
 - combined pipeline
 
+## Active API
+- `/transcribe_parakeet`
+
 ## Request inputs
 - `audio_file`
-- `model_options_json` (currently accepted for interface compatibility; the reference code path does not actively use it)
+- `model_options_json` (optional JSON object)
 
 ## Response shape
 ```json
 {
-  "model": "nvidia/parakeet-tdt-0.6b-v3",
+  "phase": 1,
+  "request_id": "uuid",
+  "model": "NVIDIA Parakeet v3",
+  "model_id": "nvidia/parakeet-tdt-0.6b-v3",
   "audio_file": "/tmp/gradio/example.wav",
-  "device": "cuda",
   "duration_seconds": 300.0,
-  "long_audio": {
-    "threshold_seconds": 480,
-    "applied": false
-  },
-  "segment_count": 42,
-  "segments": [
-    {
-      "start": 0.0,
-      "end": 7.09,
-      "segment": "Ladies and gentlemen..."
-    }
-  ],
-  "text": "Ladies and gentlemen...",
-  "request_id": "uuid",
   "execution_plan": {
-    "mode": "reference_space_replication",
-    "duration_seconds": 300.0,
-    "model_options": {}
+    "mode": "single_pass",
+    "chunking": {
+      "implemented": false,
+      "reason": "Phase 1 scaffold keeps chunk planning on CPU but does not split audio yet."
+    }
+  },
+  "preload": {
+    "cache_hit": true,
+    "load_seconds": 0.0
+  },
+  "zerogpu_timing": {
+    "gpu_window_seconds": 3.12,
+    "inference_seconds": 2.87
+  },
+  "wall_clock_timing": {
+    "probe_seconds": 0.03,
+    "preload_seconds": 0.0,
+    "postprocess_seconds": 0.01,
+    "total_seconds": 3.22
+  },
+  "raw_output": {
+    "result": {},
+    "runtime": {}
+  },
+  "normalized_output": {
+    "text": "...",
+    "word_timestamps": []
   }
 }
 ```
 
 ## Legacy code
-The previous implementation remains archived under `archive/legacy_pre_rebuild_*/`.
+The previous implementation was archived under `archive/legacy_pre_rebuild_*/` so the rebuild context stays clean.

app.py

@@ -1,9 +1,13 @@
 from __future__ import annotations
 
+import time
+from typing import Any
+
 import gradio as gr
 import spaces
 
-from src.parakeet.model import preload_parakeet_model, transcribe_audio, transcribe_audio_cpu
+from src.parakeet.config import PARAKEET_MODEL_LABEL
+from src.parakeet.model import preload_parakeet_model, run_parakeet_inference
 from src.parakeet.service import run_transcribe_parakeet_request
 from src.runtime.errors import format_exception_for_client
 from src.runtime.logging import configure_logging, get_logger, log_event
@@ -15,16 +19,28 @@ _STARTUP_PRELOAD = preload_parakeet_model(strict=False)
 log_event(logger, "startup.parakeet_preload", status=_STARTUP_PRELOAD)
 
 
-@spaces.GPU(duration=12)
-def _gpu_transcribe_parakeet(audio_file: str, session_dir: str) -> dict:
-    return transcribe_audio(audio_path=audio_file, session_dir=session_dir, runtime_device="cuda")
-
-
-def _cpu_transcribe_parakeet(audio_file: str, session_dir: str) -> dict:
-    return transcribe_audio_cpu(audio_path=audio_file, session_dir=session_dir)
+@spaces.GPU(duration=120)
+def _gpu_transcribe_parakeet(
+    audio_file: str,
+    duration_seconds: float | None,
+    model_options: dict[str, Any],
+) -> dict[str, Any]:
+    gpu_started_at = time.perf_counter()
+    result = run_parakeet_inference(
+        audio_file=audio_file,
+        duration_seconds=duration_seconds,
+        model_options=model_options,
+    )
+    return {
+        "raw_output": result["raw_output"],
+        "zerogpu_timing": {
+            "gpu_window_seconds": round(time.perf_counter() - gpu_started_at, 4),
+            **result["timing"],
+        },
+    }
 
 
-def transcribe_parakeet(audio_file: str, model_options_json: str | None) -> dict:
+def transcribe_parakeet(audio_file: str, model_options_json: str | None) -> dict[str, Any]:
     try:
         return run_transcribe_parakeet_request(
             audio_file=audio_file,
@@ -32,33 +48,25 @@ def transcribe_parakeet(audio_file: str, model_options_json: str | None) -> dict
             gpu_runner=_gpu_transcribe_parakeet,
         )
     except Exception as exc:
-        logger.exception("Parakeet GPU request failed")
-        raise gr.Error(format_exception_for_client(exc)) from exc
-
-
-def transcribe_parakeet_cpu_route(audio_file: str, model_options_json: str | None) -> dict:
-    try:
-        return run_transcribe_parakeet_request(
-            audio_file=audio_file,
-            model_options_json=model_options_json,
-            gpu_runner=_cpu_transcribe_parakeet,
-        )
-    except Exception as exc:
-        logger.exception("Parakeet CPU request failed")
+        logger.exception("Parakeet request failed")
         raise gr.Error(format_exception_for_client(exc)) from exc
 
 
 with gr.Blocks(title="Phase 1 - Parakeet only") as demo:
     gr.Markdown(
         "# Phase 1 rebuild: Parakeet-only transcription\n\n"
-        "This implementation follows the working ZeroGPU reference space and now also exposes a CPU-only debug route."
+        "The old implementation has been archived. This Space now exposes only the Phase 1 "
+        "Parakeet transcription API while ZeroGPU usage is benchmarked and stabilized."
     )
 
     audio_file = gr.Audio(sources=["upload"], type="filepath", label="Audio file")
-    model_options_json = gr.Textbox(label="model_options_json", lines=4, value="{}")
-    with gr.Row():
-        run_button = gr.Button("Run /transcribe_parakeet")
-        run_cpu_button = gr.Button("Run /transcribe_parakeet_cpu")
+    model_options_json = gr.Textbox(
+        label="model_options_json",
+        lines=8,
+        value="{}",
+        placeholder='{"compute_dtype": "bfloat16"}',
+    )
+    run_button = gr.Button("Run /transcribe_parakeet")
     output = gr.JSON(label="Parakeet transcription JSON")
 
     run_button.click(
@@ -66,16 +74,12 @@ with gr.Blocks(title="Phase 1 - Parakeet only") as demo:
         inputs=[audio_file, model_options_json],
         outputs=output,
         api_name="transcribe_parakeet",
-        api_description="Run Parakeet transcription using the working ZeroGPU reference-space code path.",
-    )
-
-    run_cpu_button.click(
-        fn=transcribe_parakeet_cpu_route,
-        inputs=[audio_file, model_options_json],
-        outputs=output,
-        api_name="transcribe_parakeet_cpu",
-        api_description="Run Parakeet transcription on CPU only, with no ZeroGPU decorator, for debugging.",
+        api_description=(
+            f"Run {PARAKEET_MODEL_LABEL} only. "
+            "This Phase 1 route performs CPU-side duration probe/preload/postprocessing and keeps the "
+            "decorated ZeroGPU window narrowly scoped to model inference."
+        ),
     )
 
 
-demo.queue().launch()
+demo.queue(default_concurrency_limit=1).launch(ssr_mode=False, theme=gr.themes.Ocean())

packages.txt

@@ -1,2 +1 @@
 ffmpeg
-libsndfile1

requirements.txt

@@ -1,5 +1,7 @@
+# Phase 1 only: Parakeet scaffold.
+# Freeze final exact versions after Phase 1 is benchmarked.
 Cython
 cuda-python
+torch==2.6.0
+torchaudio==2.6.0
 nemo_toolkit[asr] @ git+https://github.com/NVIDIA/NeMo.git@main
-pydub
-numpy

src/parakeet/model.py

@@ -1,163 +1,169 @@
 from __future__ import annotations
 
 import gc
-import os
-from pathlib import Path
+import time
 from typing import Any
 
-import numpy as np
-import torch
-from nemo.collections.asr.models import ASRModel
-from pydub import AudioSegment
+from src.parakeet.config import PARAKEET_MODEL_ID, PARAKEET_MODEL_LABEL, PARAKEET_SINGLETON_KEY
+from src.runtime.errors import DependencyLoadError, InferenceError
+from src.runtime.json_utils import serialize_for_json
+from src.runtime.preload import get_or_create_singleton, peek_singleton
 
-from src.parakeet.config import PARAKEET_MODEL_ID
 
-MODEL_NAME = PARAKEET_MODEL_ID
-MODEL = ASRModel.from_pretrained(model_name=MODEL_NAME)
-MODEL.eval()
-
-
-def preload_parakeet_model(strict: bool = True) -> dict[str, Any]:
-    return {
-        "ok": True,
-        "model": MODEL_NAME,
-        "device_detected_at_import": "not_checked",
-        "cache_hit": True,
-        "load_seconds": 0.0,
-        "strict": strict,
-    }
+def _load_parakeet_model() -> Any:
+    try:
+        import nemo.collections.asr as nemo_asr
+    except Exception as exc:
+        raise DependencyLoadError(f"Failed to import NeMo ASR for {PARAKEET_MODEL_LABEL}: {exc}") from exc
 
+    try:
+        model = nemo_asr.models.ASRModel.from_pretrained(model_name=PARAKEET_MODEL_ID)
+    except Exception as exc:
+        raise DependencyLoadError(f"Failed to download/load {PARAKEET_MODEL_ID}: {exc}") from exc
 
-def get_audio_segment(audio_path: str, start_second: float, end_second: float) -> tuple[int, np.ndarray] | None:
-    if not audio_path or not Path(audio_path).exists():
-        return None
     try:
-        start_ms = max(0, int(start_second * 1000))
-        end_ms = int(end_second * 1000)
-        if end_ms <= start_ms:
-            end_ms = start_ms + 100
-
-        audio = AudioSegment.from_file(audio_path)
-        clipped_audio = audio[start_ms:end_ms]
-
-        samples = np.array(clipped_audio.get_array_of_samples())
-        if clipped_audio.channels == 2:
-            samples = samples.reshape((-1, 2)).mean(axis=1).astype(samples.dtype)
-
-        frame_rate = clipped_audio.frame_rate or audio.frame_rate
-        if samples.size == 0 or frame_rate <= 0:
-            return None
-        return frame_rate, samples
+        model.eval()
+        model.cpu()
     except Exception:
-        return None
-
-
-def _prepare_audio(audio_path: str, session_dir: str) -> tuple[str, str | None, float]:
-    audio = AudioSegment.from_file(audio_path)
-    duration_sec = float(audio.duration_seconds)
-    target_sr = 16000
-    processed_audio_path: str | None = None
-
-    original_frame_rate = audio.frame_rate
-    original_channels = audio.channels
+        # Some wrappers may not expose cpu() until first device placement.
+        pass
+    return model
 
-    if audio.frame_rate != target_sr:
-        audio = audio.set_frame_rate(target_sr)
-    if audio.channels == 2:
-        audio = audio.set_channels(1)
-    elif audio.channels > 2:
-        raise ValueError(f"Audio has {audio.channels} channels. Only mono (1) or stereo (2) supported.")
 
-    needs_export = (audio.frame_rate != original_frame_rate) or (audio.channels != original_channels)
-    if needs_export:
-        processed_audio_path = str(Path(session_dir) / f"{Path(audio_path).stem}_resampled.wav")
-        audio.export(processed_audio_path, format="wav")
-        return processed_audio_path, processed_audio_path, duration_sec
-    return audio_path, processed_audio_path, duration_sec
+def get_cached_parakeet_model() -> Any:
+    model = peek_singleton(PARAKEET_SINGLETON_KEY)
+    if model is None:
+        raise DependencyLoadError("Parakeet model is not loaded. Call preload_parakeet_model() first.")
+    return model
 
 
-def build_segment_rows(segment_timestamps: list[dict[str, Any]]) -> list[list[str]]:
-    return [[f"{ts['start']:.2f}", f"{ts['end']:.2f}", ts['segment']] for ts in segment_timestamps]
+def preload_parakeet_model(strict: bool = True) -> dict[str, Any]:
+    started_at = time.perf_counter()
+    try:
+        _, cache_hit = get_or_create_singleton(PARAKEET_SINGLETON_KEY, _load_parakeet_model)
+        return {
+            "ok": True,
+            "model": PARAKEET_MODEL_LABEL,
+            "model_id": PARAKEET_MODEL_ID,
+            "cache_hit": cache_hit,
+            "load_seconds": round(time.perf_counter() - started_at, 4),
+        }
+    except Exception as exc:
+        if strict:
+            raise
+        return {
+            "ok": False,
+            "model": PARAKEET_MODEL_LABEL,
+            "model_id": PARAKEET_MODEL_ID,
+            "cache_hit": False,
+            "load_seconds": round(time.perf_counter() - started_at, 4),
+            "error": str(exc),
+        }
 
 
-def transcribe_audio(audio_path: str, session_dir: str, runtime_device: str) -> dict[str, Any]:
-    if not audio_path:
-        raise ValueError("No audio file path provided for transcription.")
+def _resolve_torch_dtype(torch_module: Any, dtype_name: str | None) -> Any:
+    normalized = (dtype_name or "").strip().lower()
+    mapping = {
+        "float32": torch_module.float32,
+        "float16": torch_module.float16,
+        "fp16": torch_module.float16,
+        "bfloat16": torch_module.bfloat16,
+        "bf16": torch_module.bfloat16,
+    }
+    if not normalized:
+        return None
+    if normalized not in mapping:
+        raise InferenceError(f"Unsupported compute_dtype: {dtype_name}")
+    return mapping[normalized]
 
-    actual_device = runtime_device
-    processed_audio_path: str | None = None
-    transcribe_path = audio_path
-    duration_sec = 0.0
-    long_audio_settings_applied = False
 
+def run_parakeet_inference(
+    audio_file: str,
+    duration_seconds: float | None,
+    model_options: dict[str, Any],
+) -> dict[str, Any]:
     try:
-        transcribe_path, processed_audio_path, duration_sec = _prepare_audio(audio_path, session_dir)
+        import torch
+    except Exception as exc:
+        raise DependencyLoadError(f"Failed to import torch: {exc}") from exc
+
+    model = get_cached_parakeet_model()
+    device = "cuda" if torch.cuda.is_available() else "cpu"
+    dtype_name = str(model_options.get("compute_dtype", "bfloat16"))
+    dtype = _resolve_torch_dtype(torch, dtype_name)
+
+    long_audio_threshold_seconds = float(model_options.get("long_audio_threshold_seconds", 480.0))
+    enable_long_audio_optimizations = bool(model_options.get("enable_long_audio_optimizations", True))
+    local_attention_left = int(model_options.get("local_attention_left", 256))
+    local_attention_right = int(model_options.get("local_attention_right", 256))
+    subsampling_conv_chunking_factor = int(model_options.get("subsampling_conv_chunking_factor", 1))
+    use_timestamps = bool(model_options.get("timestamps", True))
+    is_long_audio = duration_seconds is not None and duration_seconds > long_audio_threshold_seconds
+
+    applied_long_audio_settings = False
+    cleanup_notes: list[str] = []
+    inference_started_at = time.perf_counter()
 
-        MODEL.to(actual_device)
-        MODEL.to(torch.float32)
+    try:
+        model.to(device)
+        if dtype is not None:
+            model.to(dtype)
 
-        if duration_sec > 480:
+        if enable_long_audio_optimizations and is_long_audio:
             try:
-                MODEL.change_attention_model("rel_pos_local_attn", [256, 256])
-                MODEL.change_subsampling_conv_chunking_factor(1)
-                long_audio_settings_applied = True
-            except Exception:
-                long_audio_settings_applied = False
-
-        if actual_device == "cuda":
-            MODEL.to(torch.bfloat16)
-
-        output = MODEL.transcribe([transcribe_path], timestamps=True)
-
-        if (
-            not output
-            or not isinstance(output, list)
-            or not output[0]
-            or not hasattr(output[0], "timestamp")
-            or not output[0].timestamp
-            or "segment" not in output[0].timestamp
-        ):
-            raise RuntimeError("Transcription failed or produced unexpected output format.")
-
-        segment_timestamps = output[0].timestamp["segment"]
-        text = " ".join(ts["segment"].strip() for ts in segment_timestamps)
+                model.change_attention_model("rel_pos_local_attn", [local_attention_left, local_attention_right])
+                model.change_subsampling_conv_chunking_factor(subsampling_conv_chunking_factor)
+                applied_long_audio_settings = True
+            except Exception as exc:
+                cleanup_notes.append(f"long_audio_optimizations_not_applied: {exc}")
 
-        return {
-            "model": MODEL_NAME,
-            "audio_file": audio_path,
-            "device": actual_device,
-            "duration_seconds": duration_sec,
-            "long_audio": {
-                "threshold_seconds": 480,
-                "applied": long_audio_settings_applied,
-            },
-            "segment_count": len(segment_timestamps),
-            "segments": segment_timestamps,
-            "text": text,
-        }
+        transcribe_kwargs = {"timestamps": use_timestamps}
+        try:
+            outputs = model.transcribe([audio_file], use_lhotse=False, **transcribe_kwargs)
+        except TypeError:
+            outputs = model.transcribe([audio_file], **transcribe_kwargs)
     except torch.cuda.OutOfMemoryError as exc:
-        raise RuntimeError("CUDA out of memory while running Parakeet transcription.") from exc
+        raise InferenceError("CUDA out of memory while running Parakeet transcription.") from exc
+    except Exception as exc:
+        raise InferenceError(f"Parakeet inference failed: {exc}") from exc
     finally:
+        if applied_long_audio_settings:
+            try:
+                model.change_attention_model("rel_pos")
+                model.change_subsampling_conv_chunking_factor(-1)
+            except Exception as exc:
+                cleanup_notes.append(f"long_audio_reset_failed: {exc}")
         try:
-            if long_audio_settings_applied:
-                MODEL.change_attention_model("rel_pos")
-                MODEL.change_subsampling_conv_chunking_factor(-1)
-        except Exception:
-            pass
-        try:
-            if actual_device == "cuda":
-                MODEL.cpu()
+            if device == "cuda":
+                model.cpu()
             gc.collect()
-            if actual_device == "cuda":
+            if device == "cuda":
                 torch.cuda.empty_cache()
-        except Exception:
-            pass
-        if processed_audio_path and os.path.exists(processed_audio_path):
-            try:
-                os.remove(processed_audio_path)
-            except Exception:
-                pass
+        except Exception as exc:
+            cleanup_notes.append(f"cleanup_failed: {exc}")
 
-
-def transcribe_audio_cpu(audio_path: str, session_dir: str) -> dict[str, Any]:
-    return transcribe_audio(audio_path=audio_path, session_dir=session_dir, runtime_device="cpu")
+    serialized_item = serialize_for_json(outputs[0] if outputs else None)
+    return {
+        "raw_output": {
+            "result": serialized_item,
+            "runtime": {
+                "device": device,
+                "compute_dtype": dtype_name,
+                "timestamps": use_timestamps,
+                "long_audio": {
+                    "duration_seconds": duration_seconds,
+                    "threshold_seconds": long_audio_threshold_seconds,
+                    "is_long_audio": is_long_audio,
+                    "enabled": enable_long_audio_optimizations,
+                    "applied": applied_long_audio_settings,
+                    "local_attention_left": local_attention_left,
+                    "local_attention_right": local_attention_right,
+                    "subsampling_conv_chunking_factor": subsampling_conv_chunking_factor,
+                },
+                "cleanup_notes": cleanup_notes,
+            },
+        },
+        "timing": {
+            "inference_seconds": round(time.perf_counter() - inference_started_at, 4),
+        },
+    }

src/parakeet/service.py

@@ -1,29 +1,41 @@
 from __future__ import annotations
 
-import shutil
-import tempfile
-from pathlib import Path
 from typing import Any, Callable
 from uuid import uuid4
 
-from src.runtime.audio import ensure_audio_file_exists
+from src.parakeet.config import DEFAULT_MODEL_OPTIONS, PARAKEET_MODEL_ID, PARAKEET_MODEL_LABEL
+from src.parakeet.model import preload_parakeet_model
+from src.parakeet.normalize import normalize_parakeet_result
+from src.runtime.audio import ensure_audio_file_exists, probe_audio_duration_seconds
 from src.runtime.json_utils import parse_json_object
 from src.runtime.logging import get_logger, log_event
+from src.runtime.timing import Stopwatch
 
 logger = get_logger(__name__)
 
-GpuRunner = Callable[[str, str], dict[str, Any]]
+GpuRunner = Callable[[str, float | None, dict[str, Any]], dict[str, Any]]
 
 
 def build_effective_model_options(user_options: dict[str, Any]) -> dict[str, Any]:
-    return dict(user_options)
+    options = dict(DEFAULT_MODEL_OPTIONS)
+    options.update(user_options)
+    return options
 
 
 def build_parakeet_execution_plan(duration_seconds: float, model_options: dict[str, Any]) -> dict[str, Any]:
+    threshold = float(model_options.get("long_audio_threshold_seconds", DEFAULT_MODEL_OPTIONS["long_audio_threshold_seconds"]))
+    is_long_audio = duration_seconds > threshold
     return {
-        "mode": "reference_space_replication",
-        "duration_seconds": duration_seconds,
-        "model_options": model_options,
+        "mode": "single_pass",
+        "chunking": {
+            "implemented": False,
+            "reason": "Phase 1 scaffold keeps chunk planning on CPU but does not split audio yet.",
+        },
+        "long_audio": {
+            "threshold_seconds": threshold,
+            "is_long_audio": is_long_audio,
+            "optimizations_requested": bool(model_options.get("enable_long_audio_optimizations", True)),
+        },
     }
 
 
@@ -33,16 +45,54 @@ def run_transcribe_parakeet_request(
     gpu_runner: GpuRunner,
 ) -> dict[str, Any]:
     request_id = str(uuid4())
+    total_timer = Stopwatch()
+
+    log_event(logger, "parakeet.request.start", request_id=request_id, audio_file=audio_file)
+
+    probe_timer = Stopwatch()
     audio_path = ensure_audio_file_exists(audio_file)
     model_options = build_effective_model_options(parse_json_object(model_options_json))
-    session_dir = Path(tempfile.mkdtemp(prefix=f"parakeet_{request_id}_"))
-
-    log_event(logger, "parakeet.request.start", request_id=request_id, audio_file=str(audio_path))
-    try:
-        response = gpu_runner(str(audio_path), str(session_dir))
-        response["request_id"] = request_id
-        response["execution_plan"] = build_parakeet_execution_plan(response.get("duration_seconds", 0.0), model_options)
-        log_event(logger, "parakeet.request.end", request_id=request_id, duration_seconds=response.get("duration_seconds"))
-        return response
-    finally:
-        shutil.rmtree(session_dir, ignore_errors=True)
+    duration_seconds = probe_audio_duration_seconds(str(audio_path))
+    execution_plan = build_parakeet_execution_plan(duration_seconds, model_options)
+    probe_seconds = probe_timer.elapsed_seconds()
+
+    preload_timer = Stopwatch()
+    preload_info = preload_parakeet_model(strict=True)
+    preload_seconds = preload_timer.elapsed_seconds()
+
+    gpu_response = gpu_runner(str(audio_path), duration_seconds, model_options)
+
+    postprocess_timer = Stopwatch()
+    normalized_output = normalize_parakeet_result(gpu_response["raw_output"]["result"])
+    postprocess_seconds = postprocess_timer.elapsed_seconds()
+
+    response = {
+        "phase": 1,
+        "request_id": request_id,
+        "model": PARAKEET_MODEL_LABEL,
+        "model_id": PARAKEET_MODEL_ID,
+        "audio_file": str(audio_path),
+        "duration_seconds": duration_seconds,
+        "execution_plan": execution_plan,
+        "preload": preload_info,
+        "zerogpu_timing": gpu_response["zerogpu_timing"],
+        "wall_clock_timing": {
+            "probe_seconds": probe_seconds,
+            "preload_seconds": preload_seconds,
+            "postprocess_seconds": postprocess_seconds,
+            "total_seconds": total_timer.elapsed_seconds(),
+        },
+        "raw_output": gpu_response["raw_output"],
+        "normalized_output": normalized_output,
+    }
+
+    log_event(
+        logger,
+        "parakeet.request.end",
+        request_id=request_id,
+        duration_seconds=duration_seconds,
+        zerogpu_timing=response["zerogpu_timing"],
+        wall_clock_timing=response["wall_clock_timing"],
+        preload_cache_hit=preload_info.get("cache_hit"),
+    )
+    return response

tests/test_parakeet_service.py

@@ -4,18 +4,22 @@ from src.parakeet.service import build_effective_model_options, build_parakeet_e
 
 
 class ParakeetServiceTests(unittest.TestCase):
-    def test_build_effective_model_options_returns_user_options(self) -> None:
+    def test_build_effective_model_options_merges_defaults(self) -> None:
         options = build_effective_model_options({"compute_dtype": "float16"})
         self.assertEqual(options["compute_dtype"], "float16")
+        self.assertTrue(options["timestamps"])
 
-    def test_build_parakeet_execution_plan_marks_reference_mode(self) -> None:
+    def test_build_parakeet_execution_plan_marks_long_audio(self) -> None:
         plan = build_parakeet_execution_plan(
             duration_seconds=900.0,
-            model_options={"timestamps": True},
+            model_options={
+                "long_audio_threshold_seconds": 480.0,
+                "enable_long_audio_optimizations": True,
+            },
         )
-        self.assertEqual(plan["mode"], "reference_space_replication")
-        self.assertEqual(plan["duration_seconds"], 900.0)
-        self.assertTrue(plan["model_options"]["timestamps"])
+        self.assertEqual(plan["mode"], "single_pass")
+        self.assertTrue(plan["long_audio"]["is_long_audio"])
+        self.assertFalse(plan["chunking"]["implemented"])
 
 
 if __name__ == "__main__":