@elizaos/plugin-local-inference 2.0.0-beta.1 → 2.0.3-beta.3

package/dist/services/voice/self-voice-imprint.d.ts

@@ -0,0 +1,33 @@
+import { type SpeakerEncoder } from "./speaker/encoder";
+export interface AgentSelfVoiceImprintOptions {
+    encoder: SpeakerEncoder;
+    /** Minimum 16 kHz samples before one self-voice embedding is encoded. */
+    minSamples?: number;
+    /** Maximum 16 kHz samples to encode for one centroid update. */
+    maxSamples?: number;
+    /** Number of recent agent-TTS embeddings retained in the centroid. */
+    maxEmbeddings?: number;
+}
+/**
+ * Maintains a bounded centroid of the agent's own synthesized voice.
+ *
+ * The live mic path already gets WeSpeaker embeddings from attribution. This
+ * helper observes the PCM that the scheduler hands to audio output, embeds that
+ * actual TTS audio, and exposes cosine similarity against future mic turns.
+ */
+export declare class AgentSelfVoiceImprint {
+    private readonly encoder;
+    private readonly minSamples;
+    private readonly maxSamples;
+    private readonly maxEmbeddings;
+    private readonly pendingSegments;
+    private pendingSamples;
+    private readonly embeddings;
+    private centroid;
+    private queue;
+    constructor(options: AgentSelfVoiceImprintOptions);
+    observeAudio(pcm: Float32Array, sampleRate: number): Promise<void>;
+    similarity(embedding: Float32Array): Promise<number | null>;
+    private observeAudioLocked;
+}
+//# sourceMappingURL=self-voice-imprint.d.ts.map

package/dist/services/voice/self-voice-imprint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"self-voice-imprint.d.ts","sourceRoot":"","sources":["../../../src/services/voice/self-voice-imprint.ts"],"names":[],"mappings":"AAAA,OAAO,EAAqB,KAAK,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAQ3E,MAAM,WAAW,4BAA4B;IAC5C,OAAO,EAAE,cAAc,CAAC;IACxB,yEAAyE;IACzE,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,gEAAgE;IAChE,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,sEAAsE;IACtE,aAAa,CAAC,EAAE,MAAM,CAAC;CACvB;AAeD;;;;;;GAMG;AACH,qBAAa,qBAAqB;IACjC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAiB;IACzC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;IACpC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;IACpC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAS;IACvC,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAsB;IACtD,OAAO,CAAC,cAAc,CAAK;IAC3B,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAsB;IACjD,OAAO,CAAC,QAAQ,CAA6B;IAC7C,OAAO,CAAC,KAAK,CAAoC;gBAErC,OAAO,EAAE,4BAA4B;IAOjD,YAAY,CAAC,GAAG,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAQ5D,UAAU,CAAC,SAAS,EAAE,YAAY,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;YAOnD,kBAAkB;CA8BhC"}

package/dist/services/voice/shared-resources.d.ts

@@ -0,0 +1,204 @@
+/**
+ * Cross-cut resource sharing between the text + voice surfaces of a
+ * single Eliza-1 bundle.
+ *
+ * Per `packages/inference/AGENTS.md` §4 ("shared KV cache scheduling,
+ * not shared KV memory" + "one process, one llama.cpp build, one GGML
+ * pin"), text and voice MUST share:
+ *   - the tokenizer (Eliza-1/OmniVoice share a vocabulary in this lineage),
+ *   - the mmap regions for weights (deduplicated by absolute path),
+ *   - the kernel set (same shipped llama.cpp library after fusion),
+ *   - the scheduler queue (one queue, prioritised),
+ *   - the native MTP draft path (always wired for Eliza-1).
+ *
+ * What they do NOT share:
+ *   - KV cache memory (different layer counts, different head configs,
+ *     different quantizations — separate caches, shared scheduler).
+ *
+ * This module owns reference counts on each shared resource and is the
+ * single arbiter of when a voice-only region can be released. It does
+ * NOT do any I/O itself — the actual mmap, madvise, or full model-unload
+ * behavior lives behind the `MmapRegionHandle` interface so platform
+ * bindings can choose the right memory policy.
+ */
+/** Minimal structural logger — keeps this module free of upstream deps. */
+interface Logger {
+    debug?(message: string): void;
+    warn?(message: string): void;
+    info?(message: string): void;
+}
+/**
+ * The model roles that can be resident at once on the local-inference
+ * path. The `MemoryMonitor` evicts them in *ascending priority* under RAM
+ * pressure (lowest first): low-cost voice auxiliaries are cheapest to drop,
+ * the text target is the last thing to go. Voice TTS/ASR weights are evicted
+ * via `MmapRegionHandle.evictPages()`; the embedding model is unloaded by
+ * its owner.
+ */
+export type ResidentModelRole = "drafter" | "emotion" | "speaker-id" | "vision" | "embedding" | "vad" | "asr" | "tts" | "text-target";
+/**
+ * Eviction priority by role — lower evicts first. Matches the brief's
+ * `emotion < speaker-id < vision/mmproj < embedding < vad < ASR <
+ * TTS < text-target`. The cold-3 set (`emotion`, `speaker-id`) is cheap to
+ * load on demand, so evicting them is the first reclamation step under
+ * sustained pressure. See `.swarm/research/R9-memory.md` §4.1.
+ */
+export declare const RESIDENT_ROLE_PRIORITY: Readonly<Record<ResidentModelRole, number>>;
+/**
+ * An evictable resident model role. The registry walks these in ascending
+ * `evictionPriority` under memory pressure and calls `evict()` until enough
+ * RAM has been reclaimed. `evict()` MUST be idempotent (a no-op when already
+ * evicted) and the role MUST re-load lazily on next use — the monitor only
+ * frees memory, it never re-loads.
+ */
+export interface EvictableModelRole extends RefCountedResource {
+    readonly role: ResidentModelRole;
+    /** Lower evicts first. Defaults to `RESIDENT_ROLE_PRIORITY[role]`. */
+    readonly evictionPriority: number;
+    /** True while the underlying weights/pages are still resident. */
+    isResident(): boolean;
+    /** Drop the resident weights/pages. Idempotent; re-loads lazily on demand. */
+    evict(): Promise<void>;
+    /** Best-effort estimate of RAM (MB) reclaimed by `evict()`. 0 when unknown. */
+    estimatedResidentMb(): number;
+}
+/**
+ * Build an `EvictableModelRole` from a role + an `evict` callback. `release()`
+ * defaults to a no-op (the registry's refcount, not `release`, gates eviction
+ * for these); pass one if the role owns disposable state. `estimatedMb` lets
+ * the monitor know roughly how much it will reclaim — pass 0 when unknown.
+ */
+export declare function createEvictableModelRole(args: {
+    id?: string;
+    role: ResidentModelRole;
+    evictionPriority?: number;
+    estimatedMb?: number;
+    isResident: () => boolean;
+    evict: () => Promise<void>;
+    release?: () => Promise<void>;
+}): EvictableModelRole;
+/**
+ * Anything ref-counted by the registry implements this. The caller of
+ * `release()` MUST guarantee that no further reads happen on the
+ * underlying resource — for mmap regions that means no kernel call has
+ * a pointer into the freed range.
+ */
+export interface RefCountedResource {
+    readonly id: string;
+    /** Released for real when the last ref drops. Idempotent. */
+    release(): Promise<void>;
+}
+/**
+ * mmap region handle. The fused omnivoice/llama.cpp build owns the real
+ * mmap call (it happens inside the FFI) — this interface is the JS-side
+ * proxy for it, so the lifecycle code can request page eviction without
+ * binding to a specific backend.
+ */
+export interface MmapRegionHandle extends RefCountedResource {
+    /** Absolute path of the file backing the mmap region. */
+    readonly path: string;
+    /** Byte size of the mapped region. */
+    readonly sizeBytes: number;
+    /**
+     * Release memory pressure for this region. Backends may implement this
+     * as a page hint or as a full voice-runtime unload. Common mappings:
+     *   - POSIX (Linux/Android/macOS-bg): `madvise(addr, len, MADV_DONTNEED)`
+     *   - macOS (foreground / iOS):        `madvise(addr, len, MADV_FREE_REUSABLE)`
+     *   - Windows:                         `VirtualUnlock` + `OfferVirtualMemory`
+     *
+     * The lifecycle test mocks this to assert the call happened.
+     */
+    evictPages(): Promise<void>;
+}
+/** Minimal tokenizer surface text + voice both consume. */
+export interface SharedTokenizer extends RefCountedResource {
+    readonly vocabSize: number;
+}
+/**
+ * Kernel set descriptor. The actual kernels are inside the fused
+ * llama.cpp build; this is the metadata the runtime reads at startup
+ * (AGENTS.md §3 #5: "the runtime MUST log the kernel set on startup").
+ */
+export interface KernelSet extends RefCountedResource {
+    readonly kernels: ReadonlyArray<string>;
+}
+/** Scheduler graph slot. One per active engine, refcounted by surface. */
+export interface SchedulerSlot extends RefCountedResource {
+    /** Surface (text/voice) currently holding a ref. */
+    surfaces(): ReadonlyArray<"text" | "voice">;
+}
+/** Native MTP draft state is shared between text-only and voice modes. */
+export interface MtpDraftHandle extends RefCountedResource {
+    readonly modelId: string;
+}
+export declare function createMtpDraftHandle(args: {
+    modelId: string;
+}): MtpDraftHandle;
+/**
+ * Owns the shared resources for one engine. Voice + text both `acquire`
+ * and `release` against the same registry; the registry only releases
+ * the underlying resource when refcount hits zero.
+ *
+ * Thread-safety: all methods run on the single Node event loop; no
+ * locks needed. Promises returned from `release()` MUST be awaited so
+ * the lifecycle state machine can observe completion.
+ */
+export declare class SharedResourceRegistry {
+    private readonly entries;
+    private readonly log?;
+    /**
+     * When a higher-level component (the `MemoryArbiter`) owns the eviction
+     * decision for this registry, it claims ownership here so the simpler
+     * `MemoryMonitor` poll defers instead of evicting in parallel — a single
+     * eviction decision point, no double-eviction on one pressure event
+     * (#8809 AC#2). Null = no external owner, the monitor evicts itself.
+     */
+    private evictionOwner;
+    constructor(opts?: {
+        logger?: Logger;
+    });
+    /** Claim the single eviction-decision ownership for this registry. */
+    claimEvictionOwnership(owner: string): void;
+    /** Release ownership (only the current owner may release it). */
+    releaseEvictionOwnership(owner: string): void;
+    /** True when an external component owns the eviction decision. */
+    hasExternalEvictionOwner(): boolean;
+    /**
+     * Register a resource if absent, increment refcount otherwise. Returns
+     * the canonical instance — callers MUST use the returned value, not the
+     * one passed in, so a second registration with the same id resolves to
+     * the original (deduplication by id).
+     */
+    acquire<T extends RefCountedResource>(resource: T): T;
+    /**
+     * Decrement refcount; release the resource when it hits zero. Throws
+     * on unknown id — silent no-ops would hide leaks.
+     */
+    release(id: string): Promise<void>;
+    /** Diagnostic: current refcount, or 0 when not present. */
+    refCount(id: string): number;
+    /** Diagnostic: snapshot of currently-tracked resource ids. */
+    ids(): ReadonlyArray<string>;
+    /** Total tracked resources. */
+    size(): number;
+    /**
+     * Currently-resident evictable model roles, ascending by eviction
+     * priority (cheapest-to-evict first). Used by `MemoryMonitor` to walk
+     * roles under RAM pressure. Non-resident roles are filtered out — there's
+     * nothing to reclaim.
+     */
+    evictableRoles(): ReadonlyArray<EvictableModelRole>;
+    /**
+     * Evict the lowest-priority resident role and return its `id`, or `null`
+     * when nothing is evictable. Observable: emits an `info` log line so the
+     * eviction is visible in the dev console. The role re-loads lazily on
+     * next use — this only frees memory.
+     */
+    evictLowestPriorityRole(): Promise<{
+        id: string;
+        role: ResidentModelRole;
+        estimatedMb: number;
+    } | null>;
+}
+export {};
+//# sourceMappingURL=shared-resources.d.ts.map

package/dist/services/voice/shared-resources.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared-resources.d.ts","sourceRoot":"","sources":["../../../src/services/voice/shared-resources.ts"],"names":[],"mappings":"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"}

package/dist/services/voice/speaker/attribution-pipeline.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Speaker-ID + diarization attribution pipeline.
+ *
+ * Wraps a `StreamingTranscriber` so the partial / final
+ * `TranscriptUpdate`s carry diarized `VoiceSegment[]` and a
+ * `primarySpeaker`. The attribution runs in parallel with ASR — the
+ * encoder fires the moment ≥ 1 s of audio is available, and the
+ * profile store's `beginMatch` starts at speech-start.
+ *
+ * This module owns *only* the attribution logic. It does NOT replace
+ * the transcriber; callers feed PCM through both the transcriber and
+ * the attributor in parallel, then attach the resolved metadata via
+ * `BaseStreamingTranscriber.setMetadataDefaults()` once it lands.
+ *
+ * Why a separate module: the existing `VoicePipeline` is large and
+ * already handles a lot. Putting attribution behind a small adapter
+ * lets the voice pipeline opt in without entangling the diarizer /
+ * encoder / profile-store dependencies into the streaming-ASR contract.
+ */
+import type { VoiceProfileObservation, VoiceProfileStore } from "../profile-store";
+import type { VoiceInputSource, VoiceSegment, VoiceSpeaker, VoiceTurnMetadata } from "../types";
+import type { Diarizer } from "./diarizer";
+import type { SpeakerEncoder } from "./encoder";
+export interface VoiceAttributionPipelineDeps {
+    encoder: SpeakerEncoder;
+    diarizer?: Diarizer;
+    profileStore: VoiceProfileStore;
+}
+export interface VoiceAttributionRequest {
+    turnId: string;
+    source?: VoiceInputSource;
+    /** Concatenated mono 16 kHz PCM for the entire turn. */
+    pcm: Float32Array;
+    startedAtMs?: number;
+    endedAtMs?: number;
+    /** When set, the attributor will only run if the abort signal isn't yet fired. */
+    signal?: AbortSignal;
+}
+export interface VoiceAttributionOutput {
+    turnId: string;
+    primarySpeaker?: VoiceSpeaker;
+    segments: VoiceSegment[];
+    turn: VoiceTurnMetadata;
+    observation: VoiceProfileObservation | null;
+}
+/**
+ * Run the diarizer + encoder + profile-store against a complete turn's
+ * audio. The caller is responsible for slicing the audio buffer (the
+ * pipeline's prefix queue already buffers the entire utterance for
+ * the streaming-ASR path).
+ *
+ * The high-level flow:
+ *   1. Diarizer runs on the full PCM, producing per-segment speaker
+ *      tags (window-local ids).
+ *   2. We pick the longest local-speaker span and run the encoder on
+ *      that span (≥ 1 s) to produce a 256-dim embedding.
+ *   3. The embedding is matched against the profile store. On hit,
+ *      attribute the turn to the matched profile's entity. On miss,
+ *      create a new cluster profile (no entity binding — that happens
+ *      at the LifeOps layer based on utterance text).
+ *   4. Build `VoiceSegment[]` with the resolved speaker, plus a
+ *      `VoiceTurnMetadata` for downstream consumers.
+ */
+export declare class VoiceAttributionPipeline {
+    private readonly deps;
+    constructor(deps: VoiceAttributionPipelineDeps);
+    attribute(req: VoiceAttributionRequest): Promise<VoiceAttributionOutput>;
+    private buildEmptyOutput;
+    private spliceSpans;
+    private spanMsTotal;
+    private localToVoiceSegments;
+    private localToUnknownSegments;
+}
+//# sourceMappingURL=attribution-pipeline.d.ts.map

package/dist/services/voice/speaker/attribution-pipeline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"attribution-pipeline.d.ts","sourceRoot":"","sources":["../../../../src/services/voice/speaker/attribution-pipeline.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EACX,uBAAuB,EACvB,iBAAiB,EACjB,MAAM,kBAAkB,CAAC;AAE1B,OAAO,KAAK,EACX,gBAAgB,EAChB,YAAY,EACZ,YAAY,EACZ,iBAAiB,EACjB,MAAM,UAAU,CAAC;AAClB,OAAO,KAAK,EAAE,QAAQ,EAAuB,MAAM,YAAY,CAAC;AAChE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAGhD,MAAM,WAAW,4BAA4B;IAC5C,OAAO,EAAE,cAAc,CAAC;IACxB,QAAQ,CAAC,EAAE,QAAQ,CAAC;IACpB,YAAY,EAAE,iBAAiB,CAAC;CAChC;AAED,MAAM,WAAW,uBAAuB;IACvC,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,gBAAgB,CAAC;IAC1B,wDAAwD;IACxD,GAAG,EAAE,YAAY,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,kFAAkF;IAClF,MAAM,CAAC,EAAE,WAAW,CAAC;CACrB;AAED,MAAM,WAAW,sBAAsB;IACtC,MAAM,EAAE,MAAM,CAAC;IACf,cAAc,CAAC,EAAE,YAAY,CAAC;IAC9B,QAAQ,EAAE,YAAY,EAAE,CAAC;IACzB,IAAI,EAAE,iBAAiB,CAAC;IACxB,WAAW,EAAE,uBAAuB,GAAG,IAAI,CAAC;CAC5C;AAmED;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,wBAAwB;IACxB,OAAO,CAAC,QAAQ,CAAC,IAAI;gBAAJ,IAAI,EAAE,4BAA4B;IAEzD,SAAS,CACd,GAAG,EAAE,uBAAuB,GAC1B,OAAO,CAAC,sBAAsB,CAAC;IAsMlC,OAAO,CAAC,gBAAgB;IAexB,OAAO,CAAC,WAAW;IA2BnB,OAAO,CAAC,WAAW;IAMnB,OAAO,CAAC,oBAAoB;IAwC5B,OAAO,CAAC,sBAAsB;CAc9B"}

package/dist/services/voice/speaker/diarizer-fused.d.ts

@@ -0,0 +1,59 @@
+/**
+ * pyannote-segmentation-3.0 diarizer — fused `libelizainference` binding
+ * (ABI v6).
+ *
+ * Drives the native pyannote diarizer through the single fused-FFI
+ * `libelizainference` handle (the merged llama.cpp fork — see
+ * `plugins/plugin-local-inference/native/CLAUDE.md` §1) via the
+ * `eliza_inference_diariz_*` ABI. This is the SOLE on-device diarizer runtime —
+ * the same `ffi`/`ctx` pair powers VAD / wake-word / speaker / TTS / ASR.
+ *
+ * The native call returns a per-frame powerset-label sequence (293 int8
+ * labels per 5 s window, each in `[0, 7)`). Agglomerative clustering and the
+ * frame→segment reduction stay JS-side: this class one-hots the labels and
+ * feeds them through the shared pure `classifyFramesToSegments` reducer.
+ *
+ * No silent fallback: when the fused build does not export the diarizer ABI
+ * (`eliza_inference_diariz_supported() == 0`) `load()` throws a structured
+ * `DiarizerUnavailableError` (AGENTS.md §3 — never fabricate a label
+ * sequence, no standalone-lib fallback).
+ */
+import type { ElizaInferenceContextHandle, ElizaInferenceFfi } from "../ffi-bindings";
+import { type Diarizer, type DiarizerOutput, type PyannoteDiarizerModelId } from "./diarizer";
+export interface FusedDiarizerOptions {
+    ffi: ElizaInferenceFfi;
+    ctx: ElizaInferenceContextHandle | (() => ElizaInferenceContextHandle);
+    /**
+     * Optional explicit pyannote GGUF path. `null` lets the native runtime
+     * resolve the bundle's `diariz/` dir (the default).
+     */
+    ggufPath?: string | null;
+    /** Stored model id (purely informational). */
+    modelId?: PyannoteDiarizerModelId;
+}
+/**
+ * Fused-`libelizainference` pyannote-3 diarizer. Owns one
+ * `eliza_inference_diariz_*` session; `diarizeWindow()` runs one forward pass
+ * over a ~5 s window and reduces the powerset labels into speaker segments.
+ */
+export declare class FusedDiarizer implements Diarizer {
+    private readonly ffi;
+    private readonly handle;
+    readonly sampleRate = 16000;
+    readonly modelId: PyannoteDiarizerModelId;
+    private disposed;
+    private constructor();
+    /**
+     * True only when the fused `libelizainference` build exports the diarizer
+     * ABI and advertises support at runtime.
+     */
+    static isSupported(ffi: ElizaInferenceFfi | null | undefined): boolean;
+    /**
+     * Open a native diarizer session. Throws `DiarizerUnavailableError` when
+     * the runtime is not present.
+     */
+    static load(opts: FusedDiarizerOptions): Promise<FusedDiarizer>;
+    diarizeWindow(pcm: Float32Array): Promise<DiarizerOutput>;
+    dispose(): Promise<void>;
+}
+//# sourceMappingURL=diarizer-fused.d.ts.map

package/dist/services/voice/speaker/diarizer-fused.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diarizer-fused.d.ts","sourceRoot":"","sources":["../../../../src/services/voice/speaker/diarizer-fused.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,KAAK,EACX,2BAA2B,EAC3B,iBAAiB,EAEjB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAEN,KAAK,QAAQ,EACb,KAAK,cAAc,EAMnB,KAAK,uBAAuB,EAC5B,MAAM,YAAY,CAAC;AAEpB,MAAM,WAAW,oBAAoB;IACpC,GAAG,EAAE,iBAAiB,CAAC;IACvB,GAAG,EAAE,2BAA2B,GAAG,CAAC,MAAM,2BAA2B,CAAC,CAAC;IACvE;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,8CAA8C;IAC9C,OAAO,CAAC,EAAE,uBAAuB,CAAC;CAClC;AAED;;;;GAIG;AACH,qBAAa,aAAc,YAAW,QAAQ;IAM5C,OAAO,CAAC,QAAQ,CAAC,GAAG;IACpB,OAAO,CAAC,QAAQ,CAAC,MAAM;IANxB,QAAQ,CAAC,UAAU,SAAwB;IAC3C,QAAQ,CAAC,OAAO,EAAE,uBAAuB,CAAC;IAC1C,OAAO,CAAC,QAAQ,CAAS;IAEzB,OAAO;IAQP;;;OAGG;IACH,MAAM,CAAC,WAAW,CAAC,GAAG,EAAE,iBAAiB,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO;IAKtE;;;OAGG;WACU,IAAI,CAAC,IAAI,EAAE,oBAAoB,GAAG,OAAO,CAAC,aAAa,CAAC;IA6B/D,aAAa,CAAC,GAAG,EAAE,YAAY,GAAG,OAAO,CAAC,cAAc,CAAC;IAsCzD,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;CAK9B"}

package/dist/services/voice/speaker/diarizer.d.ts

@@ -0,0 +1,75 @@
+/**
+ * pyannote-segmentation-3.0 shared types and pure segmentation logic.
+ *
+ * Diarization runs EXCLUSIVELY through the fused `libelizainference`
+ * `eliza_inference_diariz_*` ABI (`FusedDiarizer` in `diarizer-fused.ts`).
+ * The standalone `libvoice_classifier` binding has been removed — there is one
+ * on-device voice runtime.
+ *
+ * This file holds the shared types (`Diarizer`, `LocalSpeakerSegment`,
+ * `DiarizerOutput`), the model-id / window constants, the structured
+ * `DiarizerUnavailableError`, and the pure `classifyFramesToSegments` reducer
+ * the fused diarizer feeds its per-frame labels through.
+ */
+export declare const PYANNOTE_SEGMENTATION_3_INT8_MODEL_ID: "pyannote-segmentation-3.0-int8";
+export declare const PYANNOTE_SEGMENTATION_3_FP32_MODEL_ID: "pyannote-segmentation-3.0-fp32";
+export type PyannoteDiarizerModelId = typeof PYANNOTE_SEGMENTATION_3_INT8_MODEL_ID | typeof PYANNOTE_SEGMENTATION_3_FP32_MODEL_ID;
+/** pyannote 3.0 segmentation window length (seconds) — model-fixed. */
+export declare const PYANNOTE_WINDOW_SECONDS = 5;
+/** Required mono sample rate (matches upstream training config). */
+export declare const PYANNOTE_SAMPLE_RATE = 16000;
+/** Number of output frames per 5 s window (= 293 in the upstream export). */
+export declare const PYANNOTE_FRAMES_PER_WINDOW = 293;
+/** Per-frame stride in milliseconds (5_000ms / 293 frames ≈ 17.06 ms). */
+export declare const PYANNOTE_FRAME_STRIDE_MS: number;
+/** Output class count — 3 single + 3 overlap + 1 silence = 7. */
+export declare const PYANNOTE_CLASS_COUNT = 7;
+/**
+ * Powerset mapping of pyannote-3 segmentation classes. Each class is
+ * the set of local speaker indices active in that frame. Class 0 is the
+ * silence/no-speaker frame. This matches the upstream `Powerset` head
+ * with `max_speakers_per_chunk=3, max_speakers_per_frame=2`.
+ */
+export declare const PYANNOTE_CLASS_TO_SPEAKERS: ReadonlyArray<ReadonlyArray<number>>;
+/** Thrown when the diarizer cannot be constructed. */
+export declare class DiarizerUnavailableError extends Error {
+    readonly code: "ort-missing" | "native-missing" | "library-missing" | "model-missing" | "model-unavailable" | "model-load-failed" | "model-shape-mismatch" | "forward-not-implemented" | "invalid-input";
+    constructor(code: DiarizerUnavailableError["code"], message: string);
+}
+/**
+ * One speaker-tagged span within a diarized window. `localSpeakerId` is
+ * **window-local** (0..2): the same physical speaker gets different
+ * local ids in different windows. The profile store re-clusters local
+ * ids into stable identities via the WeSpeaker embedding cosine.
+ */
+export interface LocalSpeakerSegment {
+    startMs: number;
+    endMs: number;
+    localSpeakerId: number;
+    /** Best class confidence over the span (max softmax). */
+    confidence: number;
+    /** True if the span contains any overlap-class frames. */
+    hasOverlap: boolean;
+}
+export interface DiarizerOutput {
+    segments: LocalSpeakerSegment[];
+    /** Number of distinct local speakers observed in the window. */
+    localSpeakerCount: number;
+    /** Total speech (any-speaker) duration in milliseconds. */
+    speechMs: number;
+}
+export interface Diarizer {
+    readonly modelId: PyannoteDiarizerModelId;
+    readonly sampleRate: number;
+    /** Process one ~5 s window of PCM. */
+    diarizeWindow(pcm: Float32Array): Promise<DiarizerOutput>;
+    dispose(): Promise<void>;
+}
+/**
+ * Reduce a per-frame class probability tensor into one segment per
+ * (local speaker × contiguous frame run). Frames where the silence
+ * class wins are excluded; frames in overlap classes contribute to
+ * **all** speakers in that class.
+ */
+export declare function classifyFramesToSegments(classProbs: Float32Array, frames: number, classCount: number, startMs: number, frameStrideMs: number): DiarizerOutput;
+//# sourceMappingURL=diarizer.d.ts.map

package/dist/services/voice/speaker/diarizer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diarizer.d.ts","sourceRoot":"","sources":["../../../../src/services/voice/speaker/diarizer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,eAAO,MAAM,qCAAqC,EACjD,gCAAyC,CAAC;AAC3C,eAAO,MAAM,qCAAqC,EACjD,gCAAyC,CAAC;AAC3C,MAAM,MAAM,uBAAuB,GAChC,OAAO,qCAAqC,GAC5C,OAAO,qCAAqC,CAAC;AAEhD,uEAAuE;AACvE,eAAO,MAAM,uBAAuB,IAAI,CAAC;AACzC,oEAAoE;AACpE,eAAO,MAAM,oBAAoB,QAAS,CAAC;AAC3C,6EAA6E;AAC7E,eAAO,MAAM,0BAA0B,MAAM,CAAC;AAC9C,0EAA0E;AAC1E,eAAO,MAAM,wBAAwB,QAC0B,CAAC;AAChE,iEAAiE;AACjE,eAAO,MAAM,oBAAoB,IAAI,CAAC;AAEtC;;;;;GAKG;AACH,eAAO,MAAM,0BAA0B,EAAE,aAAa,CAAC,aAAa,CAAC,MAAM,CAAC,CAS1E,CAAC;AAEH,sDAAsD;AACtD,qBAAa,wBAAyB,SAAQ,KAAK;IAClD,QAAQ,CAAC,IAAI,EACV,aAAa,GACb,gBAAgB,GAChB,iBAAiB,GACjB,eAAe,GACf,mBAAmB,GACnB,mBAAmB,GACnB,sBAAsB,GACtB,yBAAyB,GACzB,eAAe,CAAC;gBACP,IAAI,EAAE,wBAAwB,CAAC,MAAM,CAAC,EAAE,OAAO,EAAE,MAAM;CAKnE;AAED;;;;;GAKG;AACH,MAAM,WAAW,mBAAmB;IACnC,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,cAAc,EAAE,MAAM,CAAC;IACvB,yDAAyD;IACzD,UAAU,EAAE,MAAM,CAAC;IACnB,0DAA0D;IAC1D,UAAU,EAAE,OAAO,CAAC;CACpB;AAED,MAAM,WAAW,cAAc;IAC9B,QAAQ,EAAE,mBAAmB,EAAE,CAAC;IAChC,gEAAgE;IAChE,iBAAiB,EAAE,MAAM,CAAC;IAC1B,2DAA2D;IAC3D,QAAQ,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,QAAQ;IACxB,QAAQ,CAAC,OAAO,EAAE,uBAAuB,CAAC;IAC1C,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,sCAAsC;IACtC,aAAa,CAAC,GAAG,EAAE,YAAY,GAAG,OAAO,CAAC,cAAc,CAAC,CAAC;IAC1D,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACzB;AAmBD;;;;;GAKG;AACH,wBAAgB,wBAAwB,CACvC,UAAU,EAAE,YAAY,EACxB,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,MAAM,EACf,aAAa,EAAE,MAAM,GACnB,cAAc,CAsFhB"}

package/dist/services/voice/speaker/encoder-fused.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Speaker-embedding encoder — fused `libelizainference` binding (ABI v6).
+ *
+ * The strategic on-device voice engine is the single fused-FFI
+ * `libelizainference` library (the merged llama.cpp fork — see
+ * `plugins/plugin-local-inference/native/CLAUDE.md` §1). This class drives the
+ * WeSpeaker ResNet34-LM speaker encoder through that one native handle via the
+ * `eliza_inference_speaker_*` ABI. This is the SOLE on-device speaker-encoder
+ * runtime — the same `ffi`/`ctx` pair powers VAD / wake-word / TTS / ASR, so the
+ * whole voice pipeline runs through one library.
+ *
+ * Shape mirrors the legacy `encoder.ts::SpeakerEncoder` contract exactly:
+ *   - 16 kHz mono fp32 PCM in,
+ *   - one L2-normalized 256-d embedding out,
+ *   - `encode(pcm)` / `dispose()`.
+ *
+ * No silent fallback: when the fused build does not export the speaker ABI
+ * (`eliza_inference_speaker_supported() == 0`) `load()` throws a structured
+ * `SpeakerEncoderGgmlUnavailableError` (AGENTS.md §3 — no synthetic
+ * embeddings, no standalone-lib fallback).
+ */
+import type { ElizaInferenceContextHandle, ElizaInferenceFfi } from "../ffi-bindings";
+import type { SpeakerEncoder } from "./encoder";
+export interface FusedSpeakerEncoderOptions {
+    ffi: ElizaInferenceFfi;
+    ctx: ElizaInferenceContextHandle | (() => ElizaInferenceContextHandle);
+    /**
+     * Optional explicit WeSpeaker GGUF path. `null` lets the native runtime
+     * resolve the bundle's `speaker/` dir (the default).
+     */
+    ggufPath?: string | null;
+}
+/**
+ * Fused-`libelizainference` WeSpeaker speaker encoder. Owns one
+ * `eliza_inference_speaker_*` session; `encode()` runs one forward pass over
+ * the supplied 16 kHz PCM and returns the normalized 256-d embedding. The
+ * native side owns the model graph; this class is a thin handle.
+ */
+export declare class FusedSpeakerEncoder implements SpeakerEncoder {
+    private readonly ffi;
+    private readonly handle;
+    readonly embeddingDim = 256;
+    readonly sampleRate = 16000;
+    readonly modelId: "wespeaker-resnet34-lm-int8";
+    private disposed;
+    private constructor();
+    /**
+     * True only when the fused `libelizainference` build exports the speaker
+     * ABI and advertises support at runtime.
+     */
+    static isSupported(ffi: ElizaInferenceFfi | null | undefined): boolean;
+    /**
+     * Open a native speaker-encoder session. Throws
+     * `SpeakerEncoderGgmlUnavailableError` when the runtime is not present.
+     */
+    static load(opts: FusedSpeakerEncoderOptions): Promise<FusedSpeakerEncoder>;
+    encode(pcm: Float32Array): Promise<Float32Array>;
+    dispose(): Promise<void>;
+}
+//# sourceMappingURL=encoder-fused.d.ts.map

package/dist/services/voice/speaker/encoder-fused.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"encoder-fused.d.ts","sourceRoot":"","sources":["../../../../src/services/voice/speaker/encoder-fused.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,KAAK,EACX,2BAA2B,EAC3B,iBAAiB,EAEjB,MAAM,iBAAiB,CAAC;AACzB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAShD,MAAM,WAAW,0BAA0B;IAC1C,GAAG,EAAE,iBAAiB,CAAC;IACvB,GAAG,EAAE,2BAA2B,GAAG,CAAC,MAAM,2BAA2B,CAAC,CAAC;IACvE;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACzB;AAED;;;;;GAKG;AACH,qBAAa,mBAAoB,YAAW,cAAc;IAOxD,OAAO,CAAC,QAAQ,CAAC,GAAG;IACpB,OAAO,CAAC,QAAQ,CAAC,MAAM;IAPxB,QAAQ,CAAC,YAAY,OAA8B;IACnD,QAAQ,CAAC,UAAU,SAA4B;IAC/C,QAAQ,CAAC,OAAO,+BAAuC;IACvD,OAAO,CAAC,QAAQ,CAAS;IAEzB,OAAO;IAKP;;;OAGG;IACH,MAAM,CAAC,WAAW,CAAC,GAAG,EAAE,iBAAiB,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO;IAKtE;;;OAGG;WACU,IAAI,CAChB,IAAI,EAAE,0BAA0B,GAC9B,OAAO,CAAC,mBAAmB,CAAC;IAyBzB,MAAM,CAAC,GAAG,EAAE,YAAY,GAAG,OAAO,CAAC,YAAY,CAAC;IA6BhD,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;CAK9B"}

package/dist/services/voice/speaker/encoder-ggml.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Speaker-embedding encoder — shared constants, error class, and the
+ * embedding-distance helper.
+ *
+ * The speaker encoder runs EXCLUSIVELY through the fused `libelizainference`
+ * `eliza_inference_speaker_*` ABI (`FusedSpeakerEncoder` in `encoder-fused.ts`).
+ * The standalone `libvoice_classifier` binding that previously lived here has
+ * been removed — there is one on-device voice runtime.
+ *
+ * This module retains the pieces the fused path shares:
+ *   - the canonical dims (`SPEAKER_GGML_*`), pinned at 256 to match the C-side
+ *     `VOICE_SPEAKER_EMBEDDING_DIM` and the WeSpeaker ResNet34-LM head,
+ *   - the structured `SpeakerEncoderGgmlUnavailableError` the fused encoder
+ *     throws (no synthetic embedding fallback),
+ *   - the pure `voiceSpeakerDistance` cosine-distance helper.
+ */
+/** Output embedding dim. Matches `VOICE_SPEAKER_EMBEDDING_DIM`. */
+export declare const SPEAKER_GGML_EMBEDDING_DIM = 256;
+/** Required input sample rate. */
+export declare const SPEAKER_GGML_SAMPLE_RATE = 16000;
+/** Minimum useful audio window (~1.0 s). */
+export declare const SPEAKER_GGML_MIN_SAMPLES = 16000;
+export declare class SpeakerEncoderGgmlUnavailableError extends Error {
+    readonly code: "native-missing" | "library-missing" | "model-missing" | "model-load-failed" | "model-shape-mismatch" | "forward-not-implemented" | "invalid-input";
+    constructor(code: SpeakerEncoderGgmlUnavailableError["code"], message: string);
+}
+/**
+ * Cosine distance between two 256-dim speaker embeddings. Defined as
+ * `1 - cos_similarity(a, b)`, range [0, 2]. Mirrors the C-side
+ * `voice_speaker_distance` helper exactly.
+ */
+export declare function voiceSpeakerDistance(a: Float32Array, b: Float32Array): number;
+//# sourceMappingURL=encoder-ggml.d.ts.map

package/dist/services/voice/speaker/encoder-ggml.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"encoder-ggml.d.ts","sourceRoot":"","sources":["../../../../src/services/voice/speaker/encoder-ggml.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,mEAAmE;AACnE,eAAO,MAAM,0BAA0B,MAAM,CAAC;AAE9C,kCAAkC;AAClC,eAAO,MAAM,wBAAwB,QAAS,CAAC;AAE/C,4CAA4C;AAC5C,eAAO,MAAM,wBAAwB,QAAS,CAAC;AAE/C,qBAAa,kCAAmC,SAAQ,KAAK;IAC5D,QAAQ,CAAC,IAAI,EACV,gBAAgB,GAChB,iBAAiB,GACjB,eAAe,GACf,mBAAmB,GACnB,sBAAsB,GACtB,yBAAyB,GACzB,eAAe,CAAC;gBAElB,IAAI,EAAE,kCAAkC,CAAC,MAAM,CAAC,EAChD,OAAO,EAAE,MAAM;CAMhB;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,EAAE,YAAY,EAAE,CAAC,EAAE,YAAY,GAAG,MAAM,CA4B7E"}

package/dist/services/voice/speaker/encoder.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Speaker-embedding encoder — shared contract, model-id constants, and the
+ * `averageEmbeddings` centroid helper.
+ *
+ * The speaker encoder runs EXCLUSIVELY through the fused `libelizainference`
+ * `eliza_inference_speaker_*` ABI (`FusedSpeakerEncoder` in `encoder-fused.ts`).
+ * The standalone `WespeakerEncoder` (`libvoice_classifier`) binding has been
+ * removed — there is one on-device voice runtime.
+ *
+ * This module retains the cross-cutting pieces every encoder caller shares:
+ *   - the `SpeakerEncoder` interface the fused encoder implements,
+ *   - the stored model-id strings (kept stable so existing voice profiles in
+ *     the database stay valid),
+ *   - the canonical dims (re-exported from `encoder-ggml`),
+ *   - the `SpeakerEncoderUnavailableError` the enrollment routes raise,
+ *   - the pure `averageEmbeddings` centroid helper.
+ */
+export declare const WESPEAKER_RESNET34_LM_INT8_MODEL_ID: "wespeaker-resnet34-lm-int8";
+export declare const WESPEAKER_RESNET34_LM_FP32_MODEL_ID: "wespeaker-resnet34-lm-fp32";
+export type WespeakerModelId = typeof WESPEAKER_RESNET34_LM_INT8_MODEL_ID | typeof WESPEAKER_RESNET34_LM_FP32_MODEL_ID;
+export declare const WESPEAKER_EMBEDDING_DIM = 256;
+export declare const WESPEAKER_SAMPLE_RATE = 16000;
+export declare const WESPEAKER_MIN_SAMPLES = 16000;
+export declare class SpeakerEncoderUnavailableError extends Error {
+    readonly code: "native-missing" | "library-missing" | "model-missing" | "model-load-failed" | "model-shape-mismatch" | "forward-not-implemented" | "invalid-input";
+    constructor(code: SpeakerEncoderUnavailableError["code"], message: string);
+}
+/** The minimal contract every speaker encoder honors. */
+export interface SpeakerEncoder {
+    readonly embeddingDim: number;
+    readonly sampleRate: number;
+    readonly modelId?: string;
+    encode(pcm: Float32Array): Promise<Float32Array>;
+    dispose(): Promise<void>;
+}
+export declare function averageEmbeddings(embeddings: readonly Float32Array[]): Float32Array;
+//# sourceMappingURL=encoder.d.ts.map

package/dist/services/voice/speaker/encoder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"encoder.d.ts","sourceRoot":"","sources":["../../../../src/services/voice/speaker/encoder.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAeH,eAAO,MAAM,mCAAmC,EAC/C,4BAAqC,CAAC;AACvC,eAAO,MAAM,mCAAmC,EAC/C,4BAAqC,CAAC;AACvC,MAAM,MAAM,gBAAgB,GACzB,OAAO,mCAAmC,GAC1C,OAAO,mCAAmC,CAAC;AAE9C,eAAO,MAAM,uBAAuB,MAA6B,CAAC;AAClE,eAAO,MAAM,qBAAqB,QAA2B,CAAC;AAC9D,eAAO,MAAM,qBAAqB,QAA2B,CAAC;AAM9D,qBAAa,8BAA+B,SAAQ,KAAK;IACxD,QAAQ,CAAC,IAAI,EACV,gBAAgB,GAChB,iBAAiB,GACjB,eAAe,GACf,mBAAmB,GACnB,sBAAsB,GACtB,yBAAyB,GACzB,eAAe,CAAC;gBACP,IAAI,EAAE,8BAA8B,CAAC,MAAM,CAAC,EAAE,OAAO,EAAE,MAAM;CAKzE;AAMD,yDAAyD;AACzD,MAAM,WAAW,cAAc;IAC9B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,MAAM,CAAC,GAAG,EAAE,YAAY,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;IACjD,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACzB;AAMD,wBAAgB,iBAAiB,CAChC,UAAU,EAAE,SAAS,YAAY,EAAE,GACjC,YAAY,CAsBd"}