Wire Parakeet ASR into ZeroGPU Space

README.md

@@ -10,6 +10,7 @@ pinned: false
 python_version: 3.12.12
 preload_from_hub:
   - build-small-hackathon/figment-finetuned-model-archive figment_sft_v14p/figment-sft-v14p-lora-merged-bf16/chat_template.jinja,figment_sft_v14p/figment-sft-v14p-lora-merged-bf16/config.json,figment_sft_v14p/figment-sft-v14p-lora-merged-bf16/configuration_nemotron_h.py,figment_sft_v14p/figment-sft-v14p-lora-merged-bf16/generation_config.json,figment_sft_v14p/figment-sft-v14p-lora-merged-bf16/model-00001-of-00002.safetensors,figment_sft_v14p/figment-sft-v14p-lora-merged-bf16/model-00002-of-00002.safetensors,figment_sft_v14p/figment-sft-v14p-lora-merged-bf16/model.safetensors.index.json,figment_sft_v14p/figment-sft-v14p-lora-merged-bf16/modeling_nemotron_h.py,figment_sft_v14p/figment-sft-v14p-lora-merged-bf16/special_tokens_map.json,figment_sft_v14p/figment-sft-v14p-lora-merged-bf16/tokenizer.json,figment_sft_v14p/figment-sft-v14p-lora-merged-bf16/tokenizer_config.json
+  - nvidia/parakeet-ctc-1.1b config.json,model.safetensors,preprocessor_config.json,special_tokens_map.json,tokenizer.json,tokenizer_config.json,vocab.json
 ---
 
 # Figment
@@ -24,7 +25,7 @@ Figment turns messy field intake into a card-cited protocol workflow: confirm th
 
 | Surface | Current evidence | What it means | Boundary |
 | --- | --- | --- | --- |
-| Public Space | [build-small-hackathon/figment](https://huggingface.co/spaces/build-small-hackathon/figment) was `RUNNING` on `zero-a10g` at Space commit `e06aaf664bb7a848dd5c1958050779ef3a9feb03` on 2026-06-15. A synthetic `/run_navigator` call returned `raw_route=hf_zerogpu`, `fallback_tier=configured`, `final_route=model_with_deterministic_patches`, and `validator.passed=true` in 36.16 seconds. | The public Space reaches the published v14p BF16 model archive through HF ZeroGPU and the validator passed on the returned response. | This is one live synthetic route check. Deterministic patches still contributed, so it is live serving proof, not pure model-only competence proof. |
+| Public Space | [build-small-hackathon/figment](https://huggingface.co/spaces/build-small-hackathon/figment) was `RUNNING` on `zero-a10g` at Space commit `45df7643e9e592f8496214c436532a3ade3cfdfc` on 2026-06-15. A synthetic `/run_navigator` call returned `raw_route=hf_zerogpu`, `fallback_tier=configured`, `field_level_fallback_used=true`, `final_route=model_with_deterministic_patches`, and `validation_status=passed` in 41.87 seconds. | The public Space reaches the published v14p BF16 model archive through HF ZeroGPU and the validator passed on the returned response. | This is one live synthetic route check. Deterministic patches still contributed, so it is live serving proof, not pure model-only competence proof. |
 | Hosted Omni eval | `31/50` whole-output competence, `8/50` full fallback, `480/650` model-retained fields, `170/650` deterministic patches, and `50/50` final validation. | Hosted Omni can carry bounded fields, and the app can keep outputs inside the safety contract. | `50/50` final validation is app safety after validation, repair, and fallback. It is not pure model performance. |
 | 4B LoRA system eval | v14p repair-union on the corrected 150-case field-workflow holdout: `150/150` competence, `150/150` expected labels, `150/150` final validation, `0` deterministic patches, `0` fallback. Raw first-pass success is `146/150`; `4/150` cases close through focused model repair. | The strongest documented small-model result is model-owned output plus model repair on a synthetic/de-identified holdout. | This is not clinical validation, target-user validation, local ASR proof, or proof that raw first-pass output solved every case. |
 | Public artifacts | [model archive](https://huggingface.co/build-small-hackathon/figment-finetuned-model-archive) and [eval/training dataset](https://huggingface.co/datasets/build-small-hackathon/figment-eval-traces). | Versioned BF16/GGUF model artifacts, synthetic corpora, eval traces, and summaries are inspectable outside this checkout. | Generated `traces/`, `data/finetune/`, weights, and checkpoint folders are intentionally not part of a clean clone. |
@@ -95,12 +96,12 @@ Figment supports four runtime routes:
 | --- | --- | --- |
 | Canned fallback | `MODEL_BACKEND=canned` | No-secret app smoke, UI development, honest fallback traces. |
 | Hosted Omni | `MODEL_BACKEND=hosted_omni` with `NVIDIA_API_KEY` | Live hosted demo and hosted eval path using `nvidia/nemotron-3-nano-omni-30b-a3b-reasoning`. |
-| HF ZeroGPU v14p | `MODEL_BACKEND=hf_zerogpu` with `ZEROGPU_MODEL_REPO` / `ZEROGPU_MODEL_SUBFOLDER` | Public Space route using the published v14p BF16 merged model on Hugging Face ZeroGPU. |
+| HF ZeroGPU v14p + Parakeet ASR | `MODEL_BACKEND=hf_zerogpu`, `AUDIO_BACKEND=parakeet_nemo`, and `ALLOW_LOCAL_ASR=true` | Public Space route using the published v14p BF16 merged model plus gated Parakeet ASR draft intake on Hugging Face ZeroGPU. |
 | Local OpenAI-compatible | `MODEL_BACKEND=llama_cpp` with `LLAMA_BASE_URL` | Local text-navigation route for the 4B BF16/GGUF artifacts and local evidence bundles. |
 
 The Build Small constraint is <=32B total parameters. The hosted Omni path is tracked with a parameter-count caveat: the NVIDIA model-card body reports 31B total parameters, while sidebar counts have differed. The 4B BF16 base model, `nvidia/NVIDIA-Nemotron-3-Nano-4B-BF16`, is the local text-navigation training target.
 
-Parakeet ASR remains a gated local-audio path. Artifact presence alone is not enough; local ASR needs provider-output evidence before any local-audio claim is upgraded.
+Parakeet ASR remains evidence-gated. A Space route can use the Transformers-native `nvidia/parakeet-ctc-1.1b` Parakeet model for live audio draft intake; the original local/offline proof path still requires a real provider-output evidence bundle before any no-cloud/local-ASR claim is upgraded.
 
 ## Evaluation
 

app.py

@@ -14,6 +14,12 @@ from figment.audio_intake import draft_audio_intake as _draft_audio_intake
 from figment.config import FigmentConfig, load_config
 from figment.model_client import ModelClient, ModelClientError, hosted_audio_limits_text, validate_hosted_audio_file
 from figment.navigator import run_navigation
+from figment.parakeet_asr import (
+    ParakeetAsrError,
+    parakeet_audio_limits_text,
+    transcribe_audio_with_parakeet,
+    validate_parakeet_audio_file,
+)
 from figment.retrieval import load_protocol_cards, query_from_intake, retrieval_source_summary, search_protocol_cards
 from figment.rules import evaluate_rules, run_red_flag_checks
 from figment.sbar import render_sbar
@@ -158,6 +164,16 @@ def draft_audio_intake(
                 provider_payload = ModelClient(config).generate_audio_draft(audio_file)
             except ModelClientError as exc:
                 provider_error = f"Hosted Omni audio draft failed; typed transcript or canned fallback required. {exc}"
+    elif audio_file and not transcript.strip() and provider_payload is None and _should_use_parakeet_audio(config):
+        try:
+            validate_parakeet_audio_file(audio_file)
+        except ParakeetAsrError as exc:
+            provider_error = f"Parakeet ASR draft skipped; typed transcript or canned fallback required. {exc}"
+        else:
+            try:
+                provider_payload = transcribe_audio_with_parakeet(audio_file, config=config)
+            except ParakeetAsrError as exc:
+                provider_error = f"Parakeet ASR draft failed; typed transcript or canned fallback required. {exc}"
     draft = _draft_audio_intake(
         transcript=transcript,
         config=config,
@@ -176,6 +192,11 @@ def draft_audio_intake(
             hosted_disclosure = _hosted_audio_disclosure_text()
             draft["hosted_audio_disclosure"] = hosted_disclosure
             retention_note = f"{retention_note} {hosted_disclosure}"
+        elif _should_use_parakeet_audio(config):
+            retention_note = (
+                f"{retention_note} Parakeet ASR runs on the configured local/ZeroGPU runtime; "
+                f"limit: {parakeet_audio_limits_text()}."
+            )
         draft["audio_retention_note"] = retention_note
     if provider_error and draft.get("audio_intake_path") == "audio_received_needs_transcript_or_model":
         draft["processing_status"] = provider_error
@@ -1635,6 +1656,15 @@ def _should_use_hosted_omni_audio(config: FigmentConfig) -> bool:
     )
 
 
+def _should_use_parakeet_audio(config: FigmentConfig) -> bool:
+    return (
+        config.enable_audio_intake
+        and config.audio_backend == "parakeet_nemo"
+        and config.allow_local_asr
+        and config.model_stack == "local_4b_parakeet"
+    )
+
+
 def _hosted_audio_disclosure_text() -> str:
     return (
         "Hosted audio is sent to the configured hosted endpoint for drafting; use only synthetic or "

docs/local_parakeet_asr_evidence.md

@@ -17,6 +17,16 @@ This note separates local Parakeet ASR artifact availability from a real local A
 
 Use the helper to capture local ASR evidence:
 
+```bash
+PYTHON_DOTENV_DISABLED=true \
+python3 scripts/run_local_asr_evidence.py \
+  --audio <source-audio.wav> \
+  --transcribe-audio \
+  --provider-note "<device/runtime command>"
+```
+
+If a provider payload was captured by a separate local runtime, pass it directly:
+
 ```bash
 PYTHON_DOTENV_DISABLED=true \
 python3 scripts/run_local_asr_evidence.py \
@@ -29,6 +39,7 @@ The helper writes a timestamped evidence directory under `traces/local_asr_parak
 
 - `artifact_metadata.json`: Parakeet `.nemo` presence, size, and hash
 - `audio_metadata.json`: optional source-audio metadata and hash only; raw audio is not copied into the evidence bundle
+- `provider_payload.json`: provider output generated by `--transcribe-audio`, when that path is used
 - `provider_payload_metadata.json`: provider output file hash
 - `audio_draft.json`: Figment draft generated from the provider payload under `AUDIO_BACKEND=parakeet_nemo` and `ALLOW_LOCAL_ASR=true`
 - `draft_checks.json`: evidence-gated checks for Parakeet provenance, confirmation status, and raw-audio handling
@@ -53,4 +64,4 @@ raw_audio_stored=false
 asr_evidence_manifest_path=/tmp/figment-local-asr-artifact-only-manifest-check/asr_evidence_manifest.json
 ```
 
-This means Parakeet remains not demo-visible as local ASR proof. It can become proof only after a real local ASR adapter or device runtime produces a provider payload, and the helper records `counts_as_local_asr_proof=true`.
+This means artifact presence alone remains insufficient. The app now has a Parakeet ASR adapter path; the proof upgrades only after a real audio run produces a provider payload and the helper records `counts_as_local_asr_proof=true`.

docs/model_parameter_evidence_ledger.md

@@ -6,11 +6,11 @@ Purpose: keep parameter, route, locality, adapter, ASR, and organizer-confirmati
 
 ## Current Claim Boundary
 
-- Hosted Omni has measured eval evidence through the eval harness. The public Space is now verified runnable in no-secret canned-fallback mode, but that public Space proof is not live hosted Omni generation evidence.
-- The public Space target exists and cold-boots from the Space URL. Current public API evidence: `runtime.stage=RUNNING`, `hardware=cpu-basic`, 167 siblings, `app.py` present, `figment/observation_targets.py` present, and Space URL HTTP 200. Public workflow evidence remains no-secret canned fallback unless a later non-canned public trace is recorded.
+- Hosted Omni has measured eval evidence through the eval harness. The public Space proof is now live HF ZeroGPU v14p serving evidence, but it is not live hosted Omni generation evidence.
+- The public Space target exists and runs on HF ZeroGPU. Current public API evidence on 2026-06-15: `runtime.stage=RUNNING`, `hardware=zero-a10g`, `MODEL_BACKEND=hf_zerogpu`, `MODEL_STACK=local_4b_parakeet`, and a synthetic `/run_navigator` route with `raw_route=hf_zerogpu`, `final_route=model_with_deterministic_patches`, and `validation_status=passed`.
 - The public model archive now records published measured Figment 4B LoRA merged artifacts through `figment_sft_v14p`. The strongest measured result is v14p repair-union on the corrected 150-case field-workflow holdout: 150/150 competence, 150/150 expected labels, 150/150 final validation, 0 deterministic patches, and 0 fallback. This is tuned model-system evidence, not no-cloud or clinical validation evidence.
 - The local 4B + Parakeet route is still the preferred no-cloud/off-grid proof path. The full BF16 4B artifact and Parakeet artifact are present locally, and the tuned v14p GGUF is published, but no-cloud route proof and local ASR provider proof are still separate gates.
-- Well-Tuned wording may cite the published measured v14p tuned artifacts if the submission/judging interpretation accepts the merged-model archive and local route support. Do not imply the public no-secret Space is serving the tuned model.
+- Well-Tuned wording may cite the published measured v14p tuned artifacts if the submission/judging interpretation accepts the merged-model archive and HF ZeroGPU/local route support. Keep deterministic patch use visible when citing public Space route checks.
 - Organizer confirmation is still needed for the Omni 31B body-count versus 33B sidebar ambiguity and for any additive local stack or adapter-count interpretation.
 
 ## Parameter Ledger
@@ -20,6 +20,7 @@ Purpose: keep parameter, route, locality, adapter, ASR, and organizer-confirmati
 | Hosted Omni primary | `nvidia/Nemotron-3-Nano-Omni-30B-A3B-Reasoning-BF16`; API route `nvidia/nemotron-3-nano-omni-30b-a3b-reasoning` | NVIDIA model-card body: 31B total parameters; HF sidebar has been observed as 33B in planning docs | Roughly 3B active parameters per token is a runtime/MoE note, not the compliance number | None used in current evals | Native Omni speech encoder is part of the Omni model-card count; no separate ASR model is claimed for hosted Omni | Hosted NVIDIA API route in current evals; self-hosted no-cloud route not recorded | Pending: ask organizers whether model-card body count is acceptable if sidebar count differs | Baseline eval: 28/50 whole-output competence, 22/50 full fallback, 50/50 final validation. Follow-up eval: 31/50 competence, 8/50 full fallback, 480/650 model-retained fields, 170/650 deterministic patches, 50/50 final validation |
 | Self-hosted Omni no-cloud target | `nvidia/Nemotron-3-Nano-Omni-30B-A3B-Reasoning-BF16`, FP8, or NVFP4 variant if served locally | Same Omni 31B body-count claim, with same 33B sidebar ambiguity | Active parameters do not decide compliance | None recorded | Native Omni audio if used locally; included in Omni count if organizers accept the model-card count | Would be local/self-hosted only if served with no runtime cloud APIs | Pending for count ambiguity and hardware/runtime proof | No recorded no-cloud eval or public demo trace yet. Do not claim Off the Grid achieved |
 | Local 4B + Parakeet proof path | Text base: `nvidia/NVIDIA-Nemotron-3-Nano-4B-BF16`; tuned archive: `build-small-hackathon/figment-finetuned-model-archive`; ASR: `nvidia/parakeet-rnnt-1.1b`; local route `MODEL_BACKEND=llama_cpp`, `MODEL_STACK=local_4b_parakeet` | Workback model-card notes: 3.97B text model plus about 1.1B Parakeet, roughly 5.1B nominal before adapters | No active-parameter substitution; use additive total-count story if organizers require stack accounting | Published merged LoRA artifacts exist through `figment_sft_v14p`; exact adapter-only parameter count is not used as the primary public claim | About 1.1B for Parakeet RNNT ASR, only if real local ASR is enabled and proven | Intended local OpenAI-compatible endpoint serving the tuned GGUF plus local ASR; no-cloud only after recorded proof | Pending: confirm additive multi-model counting and adapter-count treatment | Full BF16 4B snapshot downloaded at repo revision `dfaf35de3e30f1867dd8dbc38a7fc9fb52d3914f`; `model.safetensors` is `7947142640` bytes with SHA-256 `55d4e2519456c4a9bddf596b0748d630e3b2ce6ff6f4c2b7ed3e07e2b00dad42`. Parakeet artifact downloaded at repo revision `a07b19e98a26c1873a3f2622c446a4a1ca6316cb`; `parakeet-rnnt-1.1b.nemo` is `4283105280` bytes with SHA-256 `535896f014953d945b287ac533560e20da8103c6781b152de4645528e2b60738`. The v14p repair-union measured result is 150/150 competence, 150/150 expected labels, 150/150 final validation, 0 deterministic patches, and 0 fallback on the corrected 150-case field-workflow holdout. No no-cloud local route proof, local ASR provider proof, or target-user trace is recorded yet |
+| HF ZeroGPU v14p + Parakeet ASR Space route | Text model: `build-small-hackathon/figment-finetuned-model-archive` subfolder `figment_sft_v14p/figment-sft-v14p-lora-merged-bf16`; ASR model: `nvidia/parakeet-ctc-1.1b` when `PARAKEET_ASR_RUNTIME=transformers` | 4B tuned text route plus about 1.1B Parakeet CTC ASR | No active-parameter substitution | Published merged LoRA artifacts exist through `figment_sft_v14p` | About 1.1B for Parakeet CTC ASR on the Space route | Hosted HF ZeroGPU, not no-cloud/off-grid | Pending only for any organizer-specific additive stack interpretation | The text route is live on `zero-a10g`; Parakeet ASR is implemented as gated draft intake and should be cited only after a live audio-draft route check or evidence bundle is recorded |
 | 4B Figment tuned archive | `build-small-hackathon/figment-finetuned-model-archive`, especially `figment_sft_v14p/figment-sft-v14p-lora-merged-bf16/` and `figment_sft_v14p/figment-sft-v14p-lora-merged-bf16.bf16.gguf` | Base model is the 3.97B Nemotron 4B BF16 target; merged LoRA artifacts are derived from that base | Not applicable | Published as merged BF16 and GGUF artifacts with merge manifests; adapter-only count remains a documentation detail if needed by organizers | None for text-only eval | Public HF model repo plus local OpenAI-compatible app route support | Pending only for any organizer-specific adapter-count interpretation | Public model repo is `private=False`, current commit `7da772ec7c0de20011d42780ea8afa65af4aef70`, with v1 pilot plus v5-v14p artifacts. v14p model card records the repair-union result and GGUF SHA. |
 | Canned fallback | No live model | Not a model-compliance artifact | Not applicable | Not applicable | Not applicable | Local deterministic fallback; public Space no-secret fallback verified | Not applicable | Useful for safety, deployment health, and cold-start fallback only. Cannot count as model competence, Off the Grid proof, Llama Champion proof, or Well-Tuned proof |
 
@@ -27,7 +28,7 @@ Purpose: keep parameter, route, locality, adapter, ASR, and organizer-confirmati
 
 | Claim | Required upgrade evidence |
 | --- | --- |
-| Public Space runnable | Satisfied for no-secret canned-fallback mode: app files present, clean cold boot from the Space URL, and route/fallback labeling preserved. Non-canned public model traces remain separate proof. |
+| Public Space runnable | Satisfied for HF ZeroGPU v14p: app files present, Space is `RUNNING` on `zero-a10g`, `/runtime` reports `MODEL_BACKEND=hf_zerogpu`, and a synthetic route check preserves fallback/patch labeling. |
 | Hosted model load-bearing | Cite hosted eval metrics separately from final validation: 31/50 whole-output competence and 480/650 model-retained fields in the follow-up run |
 | <=32B hosted Omni compliance | Organizer accepts the 31B model-card body count or the submission falls back to a clearly eligible smaller route |
 | Off the Grid | Recorded no-cloud run with trace evidence, either self-hosted Omni or local 4B + Parakeet/typed intake |

docs/submission_checklist.md

@@ -22,7 +22,7 @@ Primary tracker: [adversarial review action items](adversarial-review-action-ite
 | No-cloud/off-grid trace | Proof needed before claiming Off the Grid achieved | Pending |
 | Hosted Omni eval results | Measured | [hosted_omni_eval_results.md](hosted_omni_eval_results.md): 31/50 whole-output competence, 8/50 full fallback, 480/650 model-retained fields, 170/650 deterministic patches, 50/50 final validation in the follow-up run |
 | 4B LoRA system eval results | Published and measured | v14p repair-union on the corrected 150-case field-workflow holdout: 150/150 competence, 150/150 expected labels, 150/150 final validation, 0 deterministic patches, 0 fallback; raw first-pass success is 146/150 and 4/150 close through focused model repair. This is model-system evidence, not no-cloud proof or clinical validation |
-| Local 4B + Parakeet no-cloud evidence | Helpers ready; proof needed | Full BF16 4B snapshot and Parakeet `.nemo` artifact are present locally; `scripts/run_local_4b_evidence.py` captures endpoint metadata, route smoke, eval records, eval summary, and `eval_evidence_manifest.json` once the local endpoint is live; `scripts/run_local_asr_evidence.py` captures Parakeet ASR provider evidence and `asr_evidence_manifest.json`. Pending no-cloud 50-case eval and real local ASR proof |
+| Local 4B + Parakeet no-cloud evidence | Helpers ready; proof needed | Full BF16 4B snapshot and Parakeet `.nemo` artifact are present locally; `scripts/run_local_4b_evidence.py` captures endpoint metadata, route smoke, eval records, eval summary, and `eval_evidence_manifest.json` once the local endpoint is live; `scripts/run_local_asr_evidence.py --audio <source.wav> --transcribe-audio` captures Parakeet ASR provider evidence and `asr_evidence_manifest.json`. Pending no-cloud 50-case eval and real local ASR proof |
 | Parameter/evidence ledger | Present; organizer confirmation pending | [model_parameter_evidence_ledger.md](model_parameter_evidence_ledger.md) |
 | Submission claim audit | Present | `make audit-claims` scans submission-facing copy for premature Off the Grid, Llama Champion, Well-Tuned, Backyard user-use, local 4B, local ASR, demo-video, and social-post claims |
 | Evidence gate status report | Present; incomplete by design until external proofs exist | `make evidence-gates` reports each evidence gate, paths found, and next actions. Current missing gates are badge/demo/user-proof gates, not missing Hub repos: no-cloud route, Llama Champion route, local ASR provider proof, trained-responder user test, demo video, and social post |
@@ -52,7 +52,7 @@ The README may say the project is built for a real trained responder. It should
 
 ## Eval Evidence Boundary
 
-The hosted Omni eval proves model and fallback behavior through the eval harness. The public Space proof currently proves deployment health and no-secret fallback behavior, not live hosted Omni generation. Use the follow-up hosted eval run as the current hosted eval score: 31/50 whole-output hosted competence, 8/50 full fallback, 480/650 model-retained fields, 170/650 deterministic patches, and 50/50 final validation.
+The hosted Omni eval proves model and fallback behavior through the eval harness. The public Space proof currently proves live HF ZeroGPU v14p serving and deployment health, not hosted Omni generation. Use the follow-up hosted eval run as the current hosted eval score: 31/50 whole-output hosted competence, 8/50 full fallback, 480/650 model-retained fields, 170/650 deterministic patches, and 50/50 final validation.
 
 The 4B LoRA model archive proves a published, measured tuned local-model artifact. Use the v14p repair-union result as the current small-model score: 150/150 competence, 150/150 expected labels, 150/150 final validation, 0 deterministic patches, and 0 fallback on the corrected 150-case field-workflow holdout. Do not convert that into Off the Grid, local ASR, target-user, or clinical-validation evidence.
 

figment/audio_intake.py

@@ -16,7 +16,6 @@ from .config import (
     FigmentConfig,
     NVIDIA_NEMOTRON_3_NANO_4B_BF16_MODEL_ID,
     OMNI_MODEL_ID,
-    PARAKEET_ASR_MODEL_ID,
     load_config,
 )
 from .schemas import AudioDraft, AudioFieldSuggestion
@@ -211,7 +210,7 @@ def draft_audio_intake(
         audio_model_id = OMNI_MODEL_ID
         draft_source = "omni_audio_provider"
     elif provider_payload_used and audio_enabled and _is_local_parakeet_backend(config):
-        audio_model_id = PARAKEET_ASR_MODEL_ID
+        audio_model_id = config.audio_model_id
         field_fill_model_id = _local_field_fill_model_id(config)
         runtime = LOCAL_PARAKEET_RUNTIME
         path = LOCAL_PARAKEET_PATH

figment/config.py

@@ -12,6 +12,7 @@ OMNI_FP8_MODEL_ID = "nvidia/Nemotron-3-Nano-Omni-30B-A3B-Reasoning-FP8"
 OMNI_NVFP4_MODEL_ID = "nvidia/Nemotron-3-Nano-Omni-30B-A3B-Reasoning-NVFP4"
 NVIDIA_NEMOTRON_3_NANO_4B_BF16_MODEL_ID = "nvidia/NVIDIA-Nemotron-3-Nano-4B-BF16"
 PARAKEET_ASR_MODEL_ID = "nvidia/parakeet-rnnt-1.1b"
+PARAKEET_TRANSFORMERS_CTC_MODEL_ID = "nvidia/parakeet-ctc-1.1b"
 NVIDIA_OMNI_API_MODEL_ID = "nvidia/nemotron-3-nano-omni-30b-a3b-reasoning"
 NVIDIA_API_BASE_URL = "https://integrate.api.nvidia.com/v1"
 FIGMENT_CANNED_MODEL_ID = "figment-canned-deterministic"
@@ -91,6 +92,8 @@ class FigmentConfig:
     llama_base_url: str = "http://127.0.0.1:8001/v1"
     zerogpu_model_repo: str = FIGMENT_V14P_MODEL_REPO
     zerogpu_model_subfolder: str = FIGMENT_V14P_MODEL_SUBFOLDER
+    parakeet_asr_model_id: str = PARAKEET_ASR_MODEL_ID
+    parakeet_asr_runtime: str = "auto"
     trace_dir: Path = Path("traces")
 
     @classmethod
@@ -156,6 +159,9 @@ class FigmentConfig:
             or FIGMENT_V14P_MODEL_REPO,
             zerogpu_model_subfolder=os.getenv("ZEROGPU_MODEL_SUBFOLDER", FIGMENT_V14P_MODEL_SUBFOLDER).strip()
             or FIGMENT_V14P_MODEL_SUBFOLDER,
+            parakeet_asr_model_id=os.getenv("PARAKEET_ASR_MODEL_ID", PARAKEET_ASR_MODEL_ID).strip()
+            or PARAKEET_ASR_MODEL_ID,
+            parakeet_asr_runtime=os.getenv("PARAKEET_ASR_RUNTIME", "auto").strip().lower() or "auto",
             trace_dir=Path(os.getenv("FIGMENT_TRACE_DIR", "traces").strip() or "traces"),
         ).validated()
 
@@ -179,6 +185,8 @@ class FigmentConfig:
             errors.append("AUDIO_BACKEND=parakeet_nemo requires ALLOW_LOCAL_ASR=true")
         if self.audio_backend == "parakeet_nemo" and self.model_stack != "local_4b_parakeet":
             errors.append("AUDIO_BACKEND=parakeet_nemo requires MODEL_STACK=local_4b_parakeet")
+        if self.parakeet_asr_runtime not in {"auto", "nemo", "transformers"}:
+            errors.append("PARAKEET_ASR_RUNTIME must be one of ['auto', 'nemo', 'transformers']")
         errors.extend(
             _mode_consistency_errors(
                 self.figment_mode,
@@ -211,7 +219,7 @@ class FigmentConfig:
         if self.audio_backend == "omni_native":
             return OMNI_MODEL_ID
         if self.audio_backend == "parakeet_nemo":
-            return PARAKEET_ASR_MODEL_ID
+            return self.parakeet_asr_model_id
         return None
 
     @property

figment/parakeet_asr.py

@@ -0,0 +1,191 @@
+"""Parakeet ASR adapters for Figment audio draft intake."""
+
+from __future__ import annotations
+
+from functools import lru_cache
+import os
+from pathlib import Path
+import threading
+from typing import Any
+from contextlib import suppress
+import wave
+
+from .config import FigmentConfig, PARAKEET_ASR_MODEL_ID
+
+
+PARAKEET_TRANSFORMERS_CTC_MODEL_ID = "nvidia/parakeet-ctc-1.1b"
+LOCAL_ASR_MAX_BYTES = int(os.getenv("PARAKEET_ASR_MAX_BYTES", str(25 * 1024 * 1024)))
+LOCAL_ASR_MAX_SECONDS = float(os.getenv("PARAKEET_ASR_MAX_SECONDS", "120"))
+
+
+try:  # pragma: no cover - exercised on Hugging Face Spaces.
+    import spaces
+except ImportError:  # pragma: no cover - local tests run without spaces.
+
+    class _SpacesCompat:
+        @staticmethod
+        def GPU(**_kwargs: Any):
+            def decorator(func):
+                return func
+
+            return decorator
+
+    spaces = _SpacesCompat()
+
+
+class ParakeetAsrError(RuntimeError):
+    """Raised when Parakeet cannot produce a usable transcript."""
+
+
+@spaces.GPU(
+    duration=int(os.getenv("PARAKEET_ASR_DURATION_SECONDS", os.getenv("ZEROGPU_DURATION_SECONDS", "60"))),
+    size=os.getenv("PARAKEET_ASR_SIZE", os.getenv("ZEROGPU_SIZE", "large")),
+)
+def transcribe_audio_with_parakeet(audio_file: str, *, config: FigmentConfig) -> dict[str, Any]:
+    """Return a Figment provider payload from a local or ZeroGPU Parakeet ASR run."""
+
+    validate_parakeet_audio_file(audio_file)
+    model_id = getattr(config, "parakeet_asr_model_id", PARAKEET_ASR_MODEL_ID) or PARAKEET_ASR_MODEL_ID
+    runtime_name = getattr(config, "parakeet_asr_runtime", "auto") or "auto"
+    runtime = _runtime_for(runtime_name=runtime_name, model_id=model_id)
+    transcript = _clean_transcript(runtime.transcribe(audio_file))
+    if not transcript:
+        raise ParakeetAsrError("Parakeet ASR returned an empty transcript")
+    return {
+        "transcript": transcript,
+        "suggested_fields": [],
+        "missing_or_unclear_fields": [],
+        "provisional_red_flag_mentions": [],
+        "provider_metadata": {
+            "asr_model_id": model_id,
+            "asr_runtime": runtime.runtime_name,
+            "raw_audio_stored": False,
+        },
+    }
+
+
+def validate_parakeet_audio_file(audio_file: str) -> None:
+    path = Path(audio_file)
+    if not path.exists():
+        raise ParakeetAsrError(f"audio file does not exist: {audio_file}")
+    size = path.stat().st_size
+    if size > LOCAL_ASR_MAX_BYTES:
+        raise ParakeetAsrError(
+            f"audio file exceeds Parakeet ASR size limit: {size} bytes > {LOCAL_ASR_MAX_BYTES} bytes"
+        )
+    duration = _wav_duration_seconds(path)
+    if duration is not None and duration > LOCAL_ASR_MAX_SECONDS:
+        raise ParakeetAsrError(
+            f"audio file exceeds Parakeet ASR duration limit: {duration:.1f}s > {LOCAL_ASR_MAX_SECONDS:.1f}s"
+        )
+
+
+def parakeet_audio_limits_text() -> str:
+    mb = LOCAL_ASR_MAX_BYTES / (1024 * 1024)
+    return f"{mb:.0f} MB, {LOCAL_ASR_MAX_SECONDS:.0f} seconds"
+
+
+def _wav_duration_seconds(path: Path) -> float | None:
+    with suppress(wave.Error, OSError, EOFError):
+        with wave.open(str(path), "rb") as wav:
+            rate = wav.getframerate()
+            if not rate:
+                return None
+            return wav.getnframes() / rate
+    return None
+
+
+def _clean_transcript(value: Any) -> str:
+    if isinstance(value, str):
+        return value.strip()
+    return str(value or "").strip()
+
+
+@lru_cache(maxsize=8)
+def _runtime_for(*, runtime_name: str, model_id: str):
+    normalized = runtime_name.strip().lower()
+    if normalized not in {"auto", "nemo", "transformers"}:
+        raise ParakeetAsrError("PARAKEET_ASR_RUNTIME must be one of auto, nemo, transformers")
+    if normalized == "nemo":
+        return _NemoParakeetRuntime(model_id)
+    if normalized == "transformers":
+        return _TransformersParakeetRuntime(model_id)
+    if model_id == PARAKEET_ASR_MODEL_ID:
+        try:
+            return _NemoParakeetRuntime(model_id)
+        except ParakeetAsrError as exc:
+            raise ParakeetAsrError(
+                f"{model_id} is a NeMo .nemo checkpoint; install NeMo or set "
+                f"PARAKEET_ASR_MODEL_ID={PARAKEET_TRANSFORMERS_CTC_MODEL_ID} with "
+                "PARAKEET_ASR_RUNTIME=transformers"
+            ) from exc
+    return _TransformersParakeetRuntime(model_id)
+
+
+class _NemoParakeetRuntime:
+    runtime_name = "nemo"
+
+    def __init__(self, model_id: str) -> None:
+        self.model_id = model_id
+        self.lock = threading.Lock()
+        try:
+            import nemo.collections.asr as nemo_asr
+        except Exception as exc:  # pragma: no cover - NeMo is optional in local CI.
+            raise ParakeetAsrError(f"NeMo ASR is unavailable: {exc}") from exc
+        try:
+            if Path(model_id).exists():
+                self.model = nemo_asr.models.ASRModel.restore_from(restore_path=model_id)
+            else:
+                self.model = nemo_asr.models.ASRModel.from_pretrained(model_name=model_id)
+            with suppress(Exception):
+                self.model.eval()
+        except Exception as exc:  # pragma: no cover - heavyweight model path.
+            raise ParakeetAsrError(f"failed to load NeMo Parakeet model {model_id}: {exc}") from exc
+
+    def transcribe(self, audio_file: str) -> str:
+        with self.lock:
+            try:
+                result = self.model.transcribe([audio_file])
+            except Exception as exc:  # pragma: no cover - heavyweight model path.
+                raise ParakeetAsrError(f"NeMo Parakeet transcription failed: {exc}") from exc
+        return _transcription_text(result)
+
+
+class _TransformersParakeetRuntime:
+    runtime_name = "transformers"
+
+    def __init__(self, model_id: str) -> None:
+        self.model_id = model_id
+        self.lock = threading.Lock()
+        try:
+            import torch
+            from transformers import pipeline
+        except Exception as exc:
+            raise ParakeetAsrError(f"Transformers ASR dependencies are unavailable: {exc}") from exc
+        device = 0 if torch.cuda.is_available() else -1
+        kwargs: dict[str, Any] = {"model": model_id, "device": device}
+        try:
+            self.pipeline = pipeline("automatic-speech-recognition", **kwargs)
+        except Exception as exc:
+            raise ParakeetAsrError(f"failed to load Transformers Parakeet model {model_id}: {exc}") from exc
+
+    def transcribe(self, audio_file: str) -> str:
+        with self.lock:
+            try:
+                result = self.pipeline(audio_file)
+            except Exception as exc:
+                raise ParakeetAsrError(f"Transformers Parakeet transcription failed: {exc}") from exc
+        return _transcription_text(result)
+
+
+def _transcription_text(result: Any) -> str:
+    if isinstance(result, list):
+        if not result:
+            return ""
+        return _transcription_text(result[0])
+    if isinstance(result, dict):
+        return _clean_transcript(result.get("text") or result.get("transcript"))
+    text = getattr(result, "text", None)
+    if text is not None:
+        return _clean_transcript(text)
+    return _clean_transcript(result)