mirror of
https://github.com/mudler/LocalAI.git
synced 2026-06-30 11:26:32 -04:00
5d0c43ec6e
* feat(realtime): EOU-driven semantic_vad turn detection Add a `semantic_vad` turn-detection mode to the realtime API that feeds the transcription model live and decides "the user finished speaking" from the `<EOU>` end-of-utterance token rather than from silence alone. When EOU fires the turn commits immediately (~0.3s); otherwise it falls back to an eagerness-scaled silence threshold (low/med/high = 8/4/2s). Plumbing, bottom to top: - proto: `AudioTranscriptionLive` bidirectional RPC (config-first oneof, mono float PCM @16k, ready-ack / Unimplemented degrade signal) plus `TranscriptResult.eou` for the unary retranscribe gate. - pkg/grpc: client/server/base/embed scaffolding for the bidi stream, modeled on AudioTransformStream; release stream conns on terminal Recv. - parakeet-cpp: live transcription RPC with per-C-call engine locking (one live stream per turn, finalize+free at commit); bump parakeet.cpp to ABI v5 — incremental StreamingMel (no more quadratic per-feed mel recompute that delayed EOU on long turns) and the <EOU>/<EOB> split; strip the literal <EOU>/<EOB> from offline text and set Eou. - core/backend: LiveTranscriptionSession wrapper + pipeline `turn_detection:` config block (type/eagerness/retranscribe). - realtime: semantic_vad integration — live input captions streamed as transcription deltas while the user speaks, EOU-immediate commit with eagerness fallback, optional retranscribe gate (batch re-decode must also end in <EOU> to confirm), clause synthesis off the LLM token callback, and per-turn live-transcription / model_load telemetry. - UI: show the realtime pipeline components as a vertical list. Docs and tests included; opt-in via the pipeline YAML or per-session `session.update`. Non-streaming STT backends degrade to silence-only. Assisted-by: Claude Code:claude-opus-4-8 [Read] [Edit] [Write] [Bash] Assisted-by: Claude Code:claude-fable-5 [Read] [Edit] [Bash] Signed-off-by: Richard Palethorpe <io@richiejp.com> * feat(realtime): explicit formally-verified state machines + parakeet streaming driver The realtime API had several implicit state machines whose state was inferred from scattered booleans, channels, and five separate mutexes, leaving illegal/inconsistent states reachable. Make them explicit and keep the implementation in step with a formal design; rework the parakeet streaming backend along the same lines. Realtime state machines (M1-M5). Each is a sealed sum-type State/Event/Effect with a total, pure Next(state,event)->(state,[]effect) behind a single-writer Coordinator: M1 conncoord connection lifecycle: VAD toggle + once-only teardown (replaces vadServerStarted + a `done` channel closed from two sites). M2 turncoord turn detection: collapses speechStarted and the live-stream "turn open" flag into one state, so discardTurn can no longer desync them and suppress the next onset. M3 respcoord response coordination: serializes the dual-writer start/cancel so at most one response is live; one response.done per response.create. M4 compactcoord conversation compaction: single-flight (replaces the `compacting atomic.Bool` CAS). M5 ttscoord TTS pipeline: open->closing->closed, idempotent wait(), rejects enqueue-after-close (was a silent drop). The Coordinator/Sink/Next plumbing — only the sealed types and Next differed per machine — is extracted once into core/http/endpoints/openai/coordinator as a generic Coordinator[S,E,F]; each machine keeps its public API via type aliases, so no sink, call-site, or test moved. Hierarchy. session_lifecycle.fizz models M1 as the parent region with its children (M2/M3/M4) as one statechart and asserts ChildrenDieWithParent (conn torn => all children terminal, none start after teardown). respcoord and compactcoord gain an absorbing Terminated state + Shutdown event; conncoord's teardown drives the children terminal. This closes a compaction teardown gap: a fire-and-forget compaction could outlive a torn session — compactionSink now takes a session-scoped cancellable context + WaitGroup and joins the in-flight summarize+evict on shutdown. Formal verification. formal-verification/ holds one authoritative FizzBee spec per machine plus the composition spec, each with an always-assertion and a documented one-line edit that makes the checker fail (verified non-vacuous). scripts/realtime-conformance.sh is fail-closed: all Go conformance suites under -race AND a model-check of every .fizz spec; a missing FizzBee is a hard error (only the loud REALTIME_CONFORMANCE_SKIP_FIZZBEE=1 bypasses it, never in CI). FizzBee is pinned by sha256 and installed via scripts/install-fizzbee.sh into .tools/ (gitignored). Wired as make test-realtime-conformance, a CI workflow, and a pre-commit path filter. Go conformance tests are Ginkgo/Gomega (per the repo's forbidigo lint): transition tables + fixed-seed property walks + concurrent/-race specs, no rapid dependency. Design map: docs/design/realtime-state-machines.md. Parakeet streaming backend. The same treatment applied to the parakeet-cpp streaming paths: - AudioTranscriptionStream returns codes.Unimplemented for non-streaming models instead of decoding offline and emitting it as one delta + final. A client that asked for streaming learns the model cannot stream rather than receiving a batch result shaped like a stream. New grpcerrors.StreamTranscriptionUnsupported carries that signal; the HTTP /v1/audio/transcriptions stream path surfaces it as an SSE error event. Mirrors AudioTranscriptionLive, which already did this. - utteranceBoundary (boundary.go): a single definition of the end-of-utterance latch, replacing three open-coded finalEou toggles. Modelled as a two-valued type so illegal states are unrepresentable. - Shared decode driver (driver.go): streamFeedResult (one per-feed event) + feedChunk (hides the ABI v4 JSON vs text-only split) + feedSlices + flushTail. The feed loop is written once. - AudioTranscriptionLive becomes a bidi adapter: it streams the per-feed {delta,eou,eob,words} the realtime turn detector consumes and a terminal FinalResult carrying only Text. Segments/duration/eou are offline-only and no longer produced (nor read) on the live path; liveTraceState drops the terminal eou and keeps the per-feed eou_events count. - AudioTranscriptionStream + streamJSON merge into one driver-based function; streamSegmenter is generalized to the unified event with a text-only fallback that preserves the legacy (no-words) library's per-utterance segmentation. Verified: build/vet/gofumpt clean, golangci-lint 0 issues, all coordinator and parakeet packages under -race, the fail-closed conformance gate green, and make test-realtime (12 e2e WS+WebRTC). Assisted-by: Claude:claude-opus-4-8 [Claude Code] Signed-off-by: Richard Palethorpe <io@richiejp.com> --------- Signed-off-by: Richard Palethorpe <io@richiejp.com>
73 lines
3.0 KiB
Bash
Executable File
73 lines
3.0 KiB
Bash
Executable File
#!/usr/bin/env sh
|
|
#
|
|
# LocalAI pre-commit hook. Install it (once per clone) with:
|
|
#
|
|
# make install-hooks
|
|
#
|
|
# Runs only the checks relevant to what's staged:
|
|
# - Go files -> make lint + make test-coverage-check
|
|
# - core/http/react-ui -> make test-ui-coverage-check (Playwright e2e + gate)
|
|
# - realtime state machines / specs -> make test-realtime-conformance
|
|
# (respcoord/**, turncoord/**, or formal-verification/** -- a pure .fizz
|
|
# spec edit must still re-verify the design, detected separately from Go)
|
|
# A commit touching none of these is skipped entirely (other docs/YAML can't
|
|
# change lint findings, Go coverage, the UI, or the realtime conformance gate).
|
|
#
|
|
# To bypass for a single commit (e.g. a WIP checkpoint): git commit --no-verify
|
|
set -eu
|
|
|
|
repo_root="$(git rev-parse --show-toplevel)"
|
|
cd "$repo_root"
|
|
|
|
staged="$(git diff --cached --name-only --diff-filter=ACMRD)"
|
|
|
|
go_changed=0
|
|
ui_changed=0
|
|
rt_changed=0
|
|
if echo "$staged" | grep -qE '\.go$'; then go_changed=1; fi
|
|
if echo "$staged" | grep -qE '^core/http/react-ui/'; then ui_changed=1; fi
|
|
if echo "$staged" | grep -qE '^(core/http/endpoints/openai/(coordinator|respcoord|turncoord|conncoord|compactcoord|ttscoord)/|formal-verification/)'; then rt_changed=1; fi
|
|
|
|
if [ "$go_changed" -eq 0 ] && [ "$ui_changed" -eq 0 ] && [ "$rt_changed" -eq 0 ]; then
|
|
echo "pre-commit: no Go, React UI, or realtime-spec changes staged — skipping."
|
|
exit 0
|
|
fi
|
|
|
|
if [ "$go_changed" -eq 1 ]; then
|
|
# Resolve the ref golangci-lint's new-from-merge-base should compare
|
|
# against. .golangci.yml pins origin/master, which is correct in CI
|
|
# (origin == the canonical repo) but wrong from a fork clone, where
|
|
# origin/master lags behind and lint would report the whole upstream
|
|
# backlog. Prefer upstream/master, then origin/master, then master.
|
|
lint_base=""
|
|
for ref in upstream/master origin/master master; do
|
|
if git rev-parse --verify --quiet "${ref}^{commit}" >/dev/null 2>&1; then
|
|
lint_base="$ref"
|
|
break
|
|
fi
|
|
done
|
|
|
|
echo "pre-commit ▶ golangci-lint (make lint${lint_base:+, new-from $lint_base})"
|
|
make lint LINT_NEW_FROM="$lint_base"
|
|
|
|
echo "pre-commit ▶ coverage gate (make test-coverage-check) — builds and runs the"
|
|
echo " pkg/core suites plus tests/e2e; can take a few minutes."
|
|
make test-coverage-check
|
|
fi
|
|
|
|
if [ "$ui_changed" -eq 1 ]; then
|
|
echo "pre-commit ▶ React UI e2e + coverage gate (make test-ui-coverage-check) —"
|
|
echo " rebuilds the UI + ui-test-server, runs the Playwright specs, and"
|
|
echo " fails if line coverage regressed; can take a couple of minutes."
|
|
make test-ui-coverage-check
|
|
fi
|
|
|
|
if [ "$rt_changed" -eq 1 ]; then
|
|
echo "pre-commit ▶ realtime state-machine conformance (make test-realtime-conformance) —"
|
|
echo " Go transition/rapid tests under -race + FizzBee model check of the"
|
|
echo " authoritative specs. Fail-closed: needs FizzBee (make install-fizzbee)."
|
|
make test-realtime-conformance
|
|
fi
|
|
|
|
echo "pre-commit ✓ all relevant checks passed"
|