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

package/dist/services/latency-trace.d.ts

@@ -0,0 +1,346 @@
+/**
+ * End-to-end voice-loop latency tracing.
+ *
+ * One `LatencyTrace` per voice turn — a span recorder with named
+ * checkpoints from "user makes a sound" to "agent's first audio plays".
+ * The checkpoint set is fixed (`VOICE_CHECKPOINTS`) and ordered; each
+ * checkpoint is recorded at most once per turn. Missing checkpoints are
+ * surfaced as missing-checkpoint state — never synthesized — and derived
+ * metrics that depend on a missing checkpoint stay `null` (AGENTS.md §3 / §7:
+ * a missing measurement is recorded as missing, not faked).
+ *
+ * Ownership / lifecycle:
+ *   - The turn controller (`voice/turn-controller.ts`, W9) is the natural
+ *     owner of the per-turn tracer: it calls `tracer.beginTurn({...})` when
+ *     a turn opens and `tracer.endTurn(turnId)` when it finalizes/aborts.
+ *     Until that lands, callers can use the module-level
+ *     `voiceLatencyTracer` singleton + the `markVoiceLatency()` helper —
+ *     the singleton lazily opens a turn keyed by `roomId` on first mark.
+ *   - Components that produce a checkpoint either (a) hold a `tracer` and
+ *     call `tracer.mark(turnId, checkpoint)`, or (b) call the context-free
+ *     `markVoiceLatency(roomId, checkpoint)` helper. `bindVadDetector()`
+ *     bridges a `VadEventSource` onto the tracer without touching `vad.ts`.
+ *
+ * Hook points (where each checkpoint is meant to be recorded):
+ *   - `peer-utterance-end`       — (DUET ONLY) the producing agent's
+ *                                   scheduler drained its last PCM chunk into
+ *                                   the cross ring — the headline `t0` for a
+ *                                   two-agents-talking run (`voice-duet.mjs`).
+ *                                   Not recorded in the single-agent path.
+ *   - `vad-trigger`              — `VadDetector` energy-rise edge / the
+ *                                   turn controller's wake instant.
+ *   - `vad-speech-start`         — `VadDetector` Silero speech-start.
+ *   - `prewarm-fired`            — the turn controller (W9) when it calls
+ *                                   W6's `prewarmConversation`.
+ *   - `asr-first-partial`        — `StreamingTranscriber` first `partial`.
+ *   - `asr-final`                — `StreamingTranscriber` `final`.
+ *   - `llm-first-token`          — the engine generate path's first
+ *                                   `onTextChunk` (W4).
+ *   - `llm-first-replytext-char` — `StructuredFieldStreamExtractor`'s
+ *                                   `onFieldStart("replyText")`.
+ *   - `replyText-first-emotion-tag` — the field extractor / `parseExpressiveTags`
+ *                                   on the first inline expressive tag (`[happy]`
+ *                                   …) in `replyText` — emotion-markup overhead,
+ *                                   measured the way `envelopeToReplyTextMs`
+ *                                   measures envelope overhead.
+ *   - `phrase-1-to-tts`          — the scheduler/chunker (W9) on the first
+ *                                   phrase handed to the TTS backend.
+ *   - `tts-first-audio-chunk`    — the TTS backend's first PCM chunk (W7).
+ *   - `audio-first-played`       — the audio sink on the first written
+ *                                   sample (W9/W13) — single-agent path.
+ *   - `audio-first-into-peer-ring` — (DUET ONLY) the responding agent's first
+ *                                   TTS PCM chunk landed in the peer's ring
+ *                                   (the duet replacement for
+ *                                   `audio-first-played` — no speakers).
+ *
+ * Logger only, `[LatencyTracer]` prefix (AGENTS.md §9).
+ */
+import type { VadEventSource } from "./voice/types";
+/**
+ * The fixed, ordered set of latency checkpoints. The recorder enforces the
+ * order is non-decreasing in wall-clock terms only loosely — a checkpoint
+ * arriving "out of order" (a later checkpoint with an earlier timestamp) is
+ * recorded as-is and flagged; we never reorder or clamp.
+ */
+export declare const VOICE_CHECKPOINTS: readonly ["peer-utterance-end", "vad-trigger", "vad-speech-start", "prewarm-fired", "asr-first-partial", "asr-final", "llm-first-token", "llm-first-replytext-char", "replyText-first-emotion-tag", "phrase-1-to-tts", "tts-first-audio-chunk", "audio-first-played", "audio-first-into-peer-ring"];
+export type VoiceCheckpoint = (typeof VOICE_CHECKPOINTS)[number];
+/** The single-agent "core" checkpoint set — every checkpoint that is NOT
+ *  optional. A trace is `complete` iff every core checkpoint was recorded. */
+export declare const CORE_VOICE_CHECKPOINTS: ("peer-utterance-end" | "vad-trigger" | "vad-speech-start" | "prewarm-fired" | "asr-first-partial" | "asr-final" | "llm-first-token" | "llm-first-replytext-char" | "replyText-first-emotion-tag" | "phrase-1-to-tts" | "tts-first-audio-chunk" | "audio-first-played" | "audio-first-into-peer-ring")[];
+/**
+ * Derived per-turn metrics. Every field is the duration between two
+ * checkpoints; `null` whenever either endpoint checkpoint is missing for
+ * the turn — there is no fallback estimate.
+ */
+export interface LatencyDerived {
+    /** vad-trigger → llm-first-token (time-to-first-token). */
+    ttftMs: number | null;
+    /** vad-trigger → tts-first-audio-chunk (time-to-first-audio). */
+    ttfaMs: number | null;
+    /** vad-trigger → audio-first-played (time-to-audio-played; the headline). */
+    ttapMs: number | null;
+    /** vad-speech-start → asr-final (ASR finalization latency). */
+    asrFinalLatencyMs: number | null;
+    /** vad-trigger → asr-first-partial (how fast the first words appear). */
+    asrFirstPartialMs: number | null;
+    /** vad-trigger → prewarm-fired (how fast the prewarm kicks off). */
+    prewarmLatencyMs: number | null;
+    /** asr-final → llm-first-token (LLM latency once the prompt is complete). */
+    llmFirstTokenAfterAsrMs: number | null;
+    /** llm-first-token → llm-first-replytext-char (envelope-skip overhead). */
+    envelopeToReplyTextMs: number | null;
+    /** llm-first-replytext-char → phrase-1-to-tts (chunker hand-off lag). */
+    replyTextToPhrase1Ms: number | null;
+    /** phrase-1-to-tts → tts-first-audio-chunk (TTS first-chunk latency). */
+    ttsFirstChunkMs: number | null;
+    /** tts-first-audio-chunk → audio-first-played (sink/playback lag). */
+    audioSinkLatencyMs: number | null;
+    /**
+     * peer-utterance-end → llm-first-token — **THE headline number** for the
+     * two-agents-talking benchmark: how long after the peer stopped speaking
+     * the responding agent emits its first token (TTFT-from-last-utterance).
+     */
+    ttftFromUtteranceEndMs: number | null;
+    /** peer-utterance-end → llm-first-replytext-char. */
+    replyTextFirstCharFromUtteranceEndMs: number | null;
+    /** peer-utterance-end → tts-first-audio-chunk. */
+    firstTtsPcmFromUtteranceEndMs: number | null;
+    /**
+     * peer-utterance-end → audio-first-into-peer-ring — the **duet round-trip**:
+     * peer stops speaking → responding agent's first audio is back in the
+     * peer's ear (the `duet_round_trip_ms` gate reads `.p50` of this).
+     */
+    firstAudioIntoPeerRingFromUtteranceEndMs: number | null;
+    /** llm-first-token → replyText-first-emotion-tag (emotion-markup overhead);
+     *  `null` when the model emitted no inline expressive tag. */
+    emotionTagOverheadMs: number | null;
+}
+/** The derived-metric keys, in display order. */
+export declare const LATENCY_DERIVED_KEYS: readonly ["ttftFromUtteranceEndMs", "firstAudioIntoPeerRingFromUtteranceEndMs", "ttftMs", "ttfaMs", "ttapMs", "asrFinalLatencyMs", "asrFirstPartialMs", "prewarmLatencyMs", "llmFirstTokenAfterAsrMs", "envelopeToReplyTextMs", "emotionTagOverheadMs", "replyTextToPhrase1Ms", "ttsFirstChunkMs", "audioSinkLatencyMs", "ttftFromUtteranceEndMs", "replyTextFirstCharFromUtteranceEndMs", "firstTtsPcmFromUtteranceEndMs", "firstAudioIntoPeerRingFromUtteranceEndMs", "emotionTagOverheadMs"];
+export type LatencyDerivedKey = (typeof LATENCY_DERIVED_KEYS)[number];
+export interface LatencyCheckpoint {
+    name: VoiceCheckpoint;
+    /** Wall-clock ms since the turn's `t0` (the first checkpoint recorded). */
+    tMs: number;
+    /** Absolute epoch ms when the checkpoint was recorded. */
+    atEpochMs: number;
+}
+export interface LatencyTrace {
+    turnId: string;
+    roomId: string | null;
+    /** Epoch ms of the first checkpoint recorded for this turn (the t=0 ref). */
+    t0EpochMs: number;
+    /** Epoch ms when `endTurn` was called, or null while still open. */
+    closedAtEpochMs: number | null;
+    checkpoints: LatencyCheckpoint[];
+    derived: LatencyDerived;
+    /** Names of checkpoints that were never recorded for this turn. */
+    missing: VoiceCheckpoint[];
+    /** True when every checkpoint in `VOICE_CHECKPOINTS` was recorded. */
+    complete: boolean;
+    /**
+     * Non-empty when the recorder saw something it could not reconcile —
+     * a duplicate mark, an out-of-order timestamp, an unknown checkpoint.
+     * Diagnostic only; the trace is still emitted.
+     */
+    anomalies: string[];
+}
+export interface HistogramSummary {
+    count: number;
+    p50: number | null;
+    p90: number | null;
+    p99: number | null;
+    min: number | null;
+    max: number | null;
+    mean: number | null;
+}
+/**
+ * Bounded-sample running histogram for one derived metric. Keeps the last
+ * `capacity` samples (FIFO) and computes percentiles on demand. Bounded so
+ * a long-running process does not grow without limit.
+ *
+ * Exported so sibling accumulators (e.g. the Mobile Resource Workbench's
+ * `DeviceResourceMetrics`) reuse the same percentile logic instead of
+ * re-implementing it.
+ */
+export declare class BoundedHistogram {
+    private readonly capacity;
+    private readonly samples;
+    constructor(capacity: number);
+    add(value: number): void;
+    summary(): HistogramSummary;
+}
+export interface TracerOptions {
+    /** Max number of completed traces to retain in the ring. Default 64. */
+    ringCapacity?: number;
+    /** Max samples per derived-metric histogram. Default 256. */
+    histogramCapacity?: number;
+    /**
+     * Max number of concurrently-open turns. A new `beginTurn` past this cap
+     * evicts the oldest still-open turn (it is closed and emitted with whatever
+     * checkpoints it had). Guards against a leaked turn never being closed.
+     * Default 16.
+     */
+    maxOpenTurns?: number;
+}
+export declare class EndToEndLatencyTracer {
+    private readonly ring;
+    private readonly open;
+    private readonly byRoom;
+    private readonly histograms;
+    private readonly ringCapacity;
+    private readonly histogramCapacity;
+    private readonly maxOpenTurns;
+    constructor(opts?: TracerOptions);
+    /**
+     * Open a new turn. Returns the `turnId`. If `roomId` is given, subsequent
+     * context-free marks for that room route to this turn until it is closed.
+     */
+    beginTurn(args?: {
+        turnId?: string;
+        roomId?: string | null;
+    }): string;
+    /** Resolve (or lazily open) a turn for a roomId. Used by the helper. */
+    turnForRoom(roomId: string): string;
+    /**
+     * Record a checkpoint on an open turn. No-op (with a warning) if the turn
+     * is unknown or already closed — a late mark on a finalized turn is a
+     * caller bug, not something to retroactively patch into history.
+     */
+    mark(turnId: string, checkpoint: VoiceCheckpoint, atEpochMs?: number): void;
+    /** Convenience: mark a checkpoint by roomId, opening a turn if needed. */
+    markByRoom(roomId: string, checkpoint: VoiceCheckpoint, atEpochMs?: number): void;
+    /**
+     * Close an open turn: snapshot it into a `LatencyTrace`, push to the ring
+     * (evicting the oldest), and fold its derived metrics into the histograms.
+     * Idempotent for an unknown turnId. Returns the emitted trace (or null if
+     * the turn was unknown).
+     */
+    endTurn(turnId: string): LatencyTrace | null;
+    /** A read-only snapshot of an open turn (does not close it). */
+    peekTurn(turnId: string): LatencyTrace | null;
+    /** The most recent `n` completed traces, newest last. */
+    recentTraces(n?: number): LatencyTrace[];
+    /** Per-derived-metric histogram summaries over the retained sample. */
+    histogramSummaries(): Record<LatencyDerivedKey, HistogramSummary>;
+    /** Drop all retained traces, histograms, and open turns. */
+    reset(): void;
+    /** Number of turns currently open (un-closed). */
+    get openTurnCount(): number;
+    /**
+     * Bridge a VAD event source onto this tracer: subscribes to the
+     * `VadEvent` stream and emits `vad-trigger` + `vad-speech-start` on the
+     * Silero rising edge (the earliest reliable per-turn `t0`). Returns the
+     * unsubscribe function. This is the documented seam that lets the tracer
+     * hook the VAD without editing `voice/vad.ts` — the true energy-rise
+     * "wake" instant is owned by the turn controller (W9), which calls
+     * `mark(turnId, "vad-trigger")` directly; this bridge is the fallback for
+     * plain VAD-only setups.
+     */
+    bindVadDetector(source: VadEventSource, args?: {
+        roomId?: string | null;
+        onTurnOpen?: (turnId: string) => void;
+    }): () => void;
+    private snapshotTurn;
+    private computeDerived;
+}
+/**
+ * Process-wide tracer. The turn controller (W9) owns per-turn lifecycle
+ * via `beginTurn` / `endTurn`; components that only know a `roomId` use
+ * `markVoiceLatency(roomId, checkpoint)` which routes through `markByRoom`.
+ * The dev endpoint (`GET /api/dev/voice-latency`) reads this singleton.
+ */
+export declare const voiceLatencyTracer: EndToEndLatencyTracer;
+/**
+ * Record a checkpoint on the process-wide tracer, keyed by `roomId`. Opens
+ * a turn for that room on first call. No-op-safe — instrumentation must
+ * never throw into the voice loop. This is the seam every component (VAD,
+ * turn controller, engine, field extractor, chunker, TTS backend, audio
+ * sink) can call without threading a tracer reference.
+ */
+export declare function markVoiceLatency(roomId: string | null | undefined, checkpoint: VoiceCheckpoint, atEpochMs?: number): void;
+/** Close the process-wide tracer's turn for a roomId, returning the trace. */
+export declare function endVoiceLatencyTurn(roomId: string): LatencyTrace | null;
+export interface VoiceLatencyDevPayload {
+    generatedAtEpochMs: number;
+    /** Checkpoint names, in canonical order — so consumers can render headers. */
+    checkpoints: ReadonlyArray<VoiceCheckpoint>;
+    derivedKeys: ReadonlyArray<LatencyDerivedKey>;
+    openTurnCount: number;
+    traces: LatencyTrace[];
+    histograms: Record<LatencyDerivedKey, HistogramSummary>;
+}
+/** Build the JSON body for `GET /api/dev/voice-latency`. */
+export declare function buildVoiceLatencyDevPayload(tracer?: EndToEndLatencyTracer, limit?: number): VoiceLatencyDevPayload;
+/** A per-turn observation fed to `VoiceRunMetrics.recordTurn`. Every field is
+ *  optional — a turn that couldn't measure a quantity records it as missing,
+ *  never as a fabricated zero (AGENTS.md §3 / §7). */
+export interface VoiceTurnMetrics {
+    /** MTP drafter token-acceptance rate (n_drafted_accepted / n_drafted)
+     *  for this turn's generation, from the llama-server `/metrics` deltas. */
+    mtpAcceptRate?: number | null;
+    /** Tokens accepted from the drafter this turn (for an aggregate accept-rate
+     *  that weights by token count, not turn count). */
+    mtpAccepted?: number | null;
+    /** Tokens drafted this turn. */
+    mtpDrafted?: number | null;
+    /** Structured-decode token-savings % for this turn — tokens the grammar
+     *  force-filled ÷ tokens that would otherwise have been generated, ×100
+     *  (WS-4's `guided_decode_token_bench.mjs` counter; ≈28% aggregate forced
+     *  on the synthetic action set). */
+    structuredDecodeTokenSavingsPct?: number | null;
+    /** Decode throughput (tokens / second) for this turn's generation. */
+    tokensPerSecond?: number | null;
+    /** Server resident-set high-water mark in MB at the end of this turn
+     *  (`VmHWM` from `/proc/<pid>/status`). */
+    serverRssMb?: number | null;
+}
+export interface VoiceRunMetricsSummary {
+    turns: number;
+    /** MTP accept-rate, token-weighted across the run (Σaccepted / Σdrafted);
+     *  `null` when nothing was drafted / no drafter present. */
+    mtpAcceptRate: number | null;
+    mtpAccepted: number;
+    mtpDrafted: number;
+    /** Per-turn accept-rate histogram (p50/p90/p99 etc. — bounded sample). */
+    mtpAcceptRateHistogram: HistogramSummary;
+    /** Mean / histogram of the structured-decode token-savings %. */
+    structuredDecodeTokenSavingsPct: HistogramSummary;
+    /** Mean / histogram of decode tok/s. */
+    tokensPerSecond: HistogramSummary;
+    /** Server RSS over the run: first / last / max in MB + the `leakSuspected`
+     *  flag (true when RSS is monotone non-decreasing across ≥4 turns and grew
+     *  by more than `leakGrowthMbThreshold`). */
+    rss: {
+        firstMb: number | null;
+        lastMb: number | null;
+        maxMb: number | null;
+        samples: number;
+        leakSuspected: boolean;
+        growthMb: number | null;
+    };
+}
+/**
+ * Accumulates the non-latency signals over a long voice run (the duet harness
+ * feeds it per-turn). Sibling to `EndToEndLatencyTracer` (which is per-turn
+ * spans only). The duet bench report (`voice-duet-bench-<model>.json`) writes
+ * `summary()` next to the latency histograms; `eliza1_gates_collect.mjs`
+ * ingests the gate-named fields.
+ */
+export declare class VoiceRunMetrics {
+    private readonly opts;
+    private turns;
+    private mtpAccepted;
+    private mtpDrafted;
+    private readonly acceptRateHist;
+    private readonly savingsHist;
+    private readonly tokSecHist;
+    private readonly rssSamples;
+    constructor(opts?: {
+        leakGrowthMbThreshold?: number;
+    });
+    recordTurn(m: VoiceTurnMetrics): void;
+    summary(): VoiceRunMetricsSummary;
+    reset(): void;
+}
+//# sourceMappingURL=latency-trace.d.ts.map

package/dist/services/latency-trace.d.ts.map

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

package/dist/services/lib-target.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Host → fused-lib target resolution for bundle delivery (#9105 / local-
+ * inference).
+ *
+ * An Eliza-1 bundle's `files.lib[]` carries the fused `libelizainference` SET
+ * (the fused lib + its ggml/llama/mtmd sibling backends) per platform `target`.
+ * The downloader fetches ONLY the set matching the host into `<bundleRoot>/lib/`,
+ * which the desktop FFI runtime resolves with no env wiring
+ * (`desktop-fused-ffi-backend-runtime.ts` `resolveFusedLibraryPath`, path #2).
+ *
+ * Pure + injectable (platform / arch / env are all overridable) so the mapping
+ * is unit-testable on any host.
+ */
+import type { Eliza1Files, Eliza1LibFileEntry } from "./manifest";
+export interface HostLibTargetOptions {
+    platform?: NodeJS.Platform;
+    arch?: string;
+    env?: NodeJS.ProcessEnv;
+    /** Prefer a GPU-accelerated target when the bundle hosts one. */
+    preferGpu?: boolean;
+}
+/**
+ * Ordered list of acceptable `target` keys for the host, best-first. The
+ * downloader picks the first target the bundle actually hosts.
+ *
+ *   - `ELIZA_INFERENCE_LIB_TARGET` pins a single target (power users / CI).
+ *   - Mobile (`ELIZA_PLATFORM=android|ios`) returns `[]` — phones ship the lib
+ *     natively (jniLibs / xcframework), never via bundle delivery.
+ *   - CPU is preferred by default: the fused lib always has GGML_CPU built in,
+ *     so the CPU set works on every host and is the smallest download. GPU sets
+ *     (`…-cuda`) are opt-in via `preferGpu` or the env pin.
+ *   - macOS arm64 maps to the `metal` set, which itself carries the CPU
+ *     fallback, so it is the canonical mac target.
+ */
+export declare function resolveHostLibTargets(opts?: HostLibTargetOptions): string[];
+export interface SelectedLibTarget {
+    readonly target: string;
+    readonly files: ReadonlyArray<Eliza1LibFileEntry>;
+}
+/**
+ * Pick the bundle's lib file set for the first host target the manifest
+ * actually carries. Returns null when the bundle has no `lib[]` or hosts no
+ * target the host accepts (⇒ the runtime falls back to other resolution paths,
+ * ultimately cloud).
+ */
+export declare function selectBundleLibFiles(manifest: {
+    files: Pick<Eliza1Files, "lib">;
+}, targets: ReadonlyArray<string>): SelectedLibTarget | null;
+/**
+ * Flat staged filename under `<bundleRoot>/lib/` for a lib entry. Always a
+ * basename (any directory component in `name`/`path` is stripped) so a manifest
+ * can never write outside the lib dir.
+ */
+export declare function libStagedName(entry: Eliza1LibFileEntry): string;
+//# sourceMappingURL=lib-target.d.ts.map

package/dist/services/lib-target.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lib-target.d.ts","sourceRoot":"","sources":["../../src/services/lib-target.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAElE,MAAM,WAAW,oBAAoB;IACpC,QAAQ,CAAC,EAAE,MAAM,CAAC,QAAQ,CAAC;IAC3B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;IACxB,iEAAiE;IACjE,SAAS,CAAC,EAAE,OAAO,CAAC;CACpB;AAOD;;;;;;;;;;;;GAYG;AACH,wBAAgB,qBAAqB,CACpC,IAAI,GAAE,oBAAyB,GAC7B,MAAM,EAAE,CAqBV;AAED,MAAM,WAAW,iBAAiB;IACjC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC,kBAAkB,CAAC,CAAC;CAClD;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CACnC,QAAQ,EAAE;IAAE,KAAK,EAAE,IAAI,CAAC,WAAW,EAAE,KAAK,CAAC,CAAA;CAAE,EAC7C,OAAO,EAAE,aAAa,CAAC,MAAM,CAAC,GAC5B,iBAAiB,GAAG,IAAI,CAQ1B;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,kBAAkB,GAAG,MAAM,CAK/D"}

package/dist/services/live-signals.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Live device signals for the capability-driven `auto` routing policy.
+ *
+ * `classifyDeviceTier()` is a *static* assessment — it scores the hardware once
+ * and caches the result. But a device that classifies MAX/GOOD at session start
+ * can still become a poor place to run local inference *right now*: a sustained
+ * workload pushes the SoC into thermal throttling, or decode throughput collapses
+ * under memory pressure. Those are live, time-varying signals the static tier
+ * cannot see.
+ *
+ * This module exposes the two live signals the `auto` branch demotes on:
+ *
+ *   - **thermal state** — read from the device bridge's most recent device
+ *     capabilities (`nominal | fair | serious | critical | unknown`). `serious`
+ *     or `critical` means the OS is actively throttling clocks; forcing local
+ *     inference there makes turns slower than cloud and worsens the throttle.
+ *   - **decode throughput** — the recent p50 decode tokens/sec from
+ *     `inferenceTelemetry`. When it falls below a usable budget the on-device
+ *     path is no longer competitive and `auto` routes to cloud.
+ *
+ * Both signals are *optional*: a quantity the host could not measure is reported
+ * as `null` (never a fabricated `0`), and a `null` signal never demotes — the
+ * static tier decision stands. The default source reads the real subsystems; a
+ * test or alternate host can inject its own via `setLiveDeviceSignalsSource`.
+ */
+/** Thermal pressure reported by the OS. Mirrors the device-bridge wire enum. */
+export type ThermalState = "nominal" | "fair" | "serious" | "critical" | "unknown";
+/**
+ * The telemetry metric name carrying recent on-device decode throughput
+ * (tokens/sec). The backend records this after a generation completes; until
+ * then `summary()` returns a `count: 0` row and the signal is `null`.
+ */
+export declare const DECODE_TPS_METRIC = "inference.decode_tps";
+/**
+ * Minimum decode throughput (tokens/sec) below which the local path is no longer
+ * worth keeping under `auto`. Roughly the floor where on-device generation feels
+ * slower than a cloud round-trip on a constrained mobile SoC.
+ */
+export declare const MIN_DECODE_TPS_BUDGET = 6;
+/**
+ * Approximate decoded-token count for a generated string when an exact tokenizer
+ * count is not reachable from the call site. English averages ~4 characters per
+ * token; this is deliberately coarse — it only feeds a p50 the router compares
+ * against {@link MIN_DECODE_TPS_BUDGET}, never a billing or context-window count.
+ */
+export declare function estimateDecodeTokens(text: string): number;
+/**
+ * Record one on-device decode-throughput observation into the telemetry ring the
+ * `auto` router reads via {@link DECODE_TPS_METRIC}. This is the producer that
+ * activates the dormant TPS demotion signal: backends call it after a real local
+ * generation completes with a known decoded-token count and wall-clock decode
+ * span.
+ *
+ * Drops the sample (records nothing) when it would be noise rather than signal:
+ * an empty/aborted generation, a sub-{@link MIN_TOKENS_FOR_TPS_SAMPLE} reply, or
+ * a non-positive elapsed time (a clock that did not advance). Never throws —
+ * `inferenceTelemetry.record` already guards the call site.
+ */
+export declare function recordDecodeThroughput(sample: {
+    tokens: number;
+    elapsedMs: number;
+}): void;
+/** A point-in-time snapshot of the live device signals. */
+export interface LiveDeviceSignals {
+    /** Current OS thermal pressure, or `null` when no device reported it. */
+    thermalState: ThermalState | null;
+    /** Recent p50 decode throughput in tokens/sec, or `null` when unmeasured. */
+    decodeTokensPerSecond: number | null;
+}
+/** A source of live device signals — swappable for tests and alternate hosts. */
+export type LiveDeviceSignalsSource = () => LiveDeviceSignals;
+/** Read the current live device signals. */
+export declare function readLiveDeviceSignals(): LiveDeviceSignals;
+/**
+ * Override the live-signals source. Pass `null` to restore the default
+ * (device-bridge + telemetry) source. Intended for tests and alternate hosts.
+ */
+export declare function setLiveDeviceSignalsSource(source: LiveDeviceSignalsSource | null): void;
+/**
+ * Whether the live signals say the device should be demoted off local for now,
+ * even though the static tier favours local. True when the OS is throttling
+ * (`serious`/`critical`) or measured decode throughput sits below the budget.
+ * A `null` signal never demotes.
+ */
+export declare function liveSignalsDemoteLocal(signals: LiveDeviceSignals): boolean;
+//# sourceMappingURL=live-signals.d.ts.map

package/dist/services/live-signals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"live-signals.d.ts","sourceRoot":"","sources":["../../src/services/live-signals.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAKH,gFAAgF;AAChF,MAAM,MAAM,YAAY,GACrB,SAAS,GACT,MAAM,GACN,SAAS,GACT,UAAU,GACV,SAAS,CAAC;AAEb;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,yBAAyB,CAAC;AAExD;;;;GAIG;AACH,eAAO,MAAM,qBAAqB,IAAI,CAAC;AAUvC;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEzD;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE;IAC9C,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;CAClB,GAAG,IAAI,CAeP;AAED,2DAA2D;AAC3D,MAAM,WAAW,iBAAiB;IACjC,yEAAyE;IACzE,YAAY,EAAE,YAAY,GAAG,IAAI,CAAC;IAClC,6EAA6E;IAC7E,qBAAqB,EAAE,MAAM,GAAG,IAAI,CAAC;CACrC;AAED,iFAAiF;AACjF,MAAM,MAAM,uBAAuB,GAAG,MAAM,iBAAiB,CAAC;AA+B9D,4CAA4C;AAC5C,wBAAgB,qBAAqB,IAAI,iBAAiB,CAEzD;AAED;;;GAGG;AACH,wBAAgB,0BAA0B,CACzC,MAAM,EAAE,uBAAuB,GAAG,IAAI,GACpC,IAAI,CAEN;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAc1E"}

package/dist/services/llama-server-metrics.d.ts

@@ -0,0 +1,114 @@
+/**
+ * Scraper for llama-server's `/metrics` (Prometheus exposition format)
+ * endpoint. Translates the running counters into the
+ * Anthropic-SDK-shaped `usage` block that callers already know how to
+ * consume from the cloud Anthropic plugin.
+ *
+ * llama-server publishes the following counters (per-process, monotonic):
+ *
+ *   llamacpp:n_decode_total           — context tokens decoded (prefill + gen)
+ *   llamacpp:n_tokens_predicted_total — output tokens
+ *   llamacpp:prompt_tokens_total      — total input tokens accepted
+ *   llamacpp:n_past_max               — high-water mark of cached past-tokens
+ *   llamacpp:n_prompt_tokens_processed_total — fresh tokens prefilled
+ *                                       (i.e. cache MISS), excludes cache hits
+ *   llamacpp:kv_cache_tokens          — current size of KV cache (gauge)
+ *   llamacpp:kv_cache_used_cells      — slots with active KV (gauge)
+ *
+ * For MTP speculative decoding, the fork additionally publishes:
+ *
+ *   llamacpp:n_drafted_total          — drafter-emitted tokens
+ *   llamacpp:n_drafted_accepted_total — accepted speculative tokens
+ *
+ * The mapping into Anthropic shape:
+ *
+ *   prompt_tokens_total                              → input_tokens
+ *   n_tokens_predicted_total                         → output_tokens
+ *   n_prompt_tokens_processed_total                  → cache_creation_input_tokens
+ *   prompt_tokens_total - n_prompt_tokens_processed_total → cache_read_input_tokens
+ *   n_drafted_total / n_drafted_accepted_total       → MTP extension fields
+ *
+ * Counters are taken as deltas across two snapshots: take one before
+ * `generate`, one after, and subtract. Losing a few samples to process
+ * restart is acceptable — the deltas are useful for the call's own
+ * usage accounting, not for global monitoring.
+ */
+export interface LlamaServerMetricSnapshot {
+    /** Wall-clock ms when the snapshot was taken; useful for diagnostics. */
+    takenAtMs: number;
+    /** True when `/metrics` was fetched and parsed. False means scrape failure. */
+    scrapeOk?: boolean;
+    /** True when the scrape included at least one generation/speculation counter. */
+    hasGenerationCounters?: boolean;
+    promptTokensTotal: number;
+    predictedTokensTotal: number;
+    /** Tokens that had to be freshly prefilled — i.e. cache MISS this turn. */
+    promptTokensProcessedTotal: number;
+    draftedTotal: number;
+    acceptedTotal: number;
+    /** Current size of the KV cache (gauge). */
+    kvCacheTokens: number;
+    /** Number of slots currently holding active KV (gauge). */
+    kvCacheUsedCells: number;
+}
+/**
+ * Parse a Prometheus exposition-format payload into a metric snapshot.
+ * Unknown or malformed lines are silently skipped — counters we don't
+ * recognise are not interesting and metric exporters add new ones over
+ * time.
+ *
+ * llama-server usually exposes one sample per metric (no labels), e.g.
+ *   `llamacpp:prompt_tokens_total 1234`
+ * Some MTP forks expose per-slot labelled samples, e.g.
+ *   `llamacpp:n_drafted_accepted_total{slot_id="0"} 12`
+ * Labelled samples are summed unless an unlabelled total exists for the same
+ * canonical field, in which case the unlabelled total wins.
+ */
+export declare function parsePrometheusMetrics(body: string, takenAtMs?: number): LlamaServerMetricSnapshot;
+/**
+ * Anthropic-SDK-shaped usage block, optionally extended with MTP
+ * speculative-decoding metrics. The cloud plugin (plugin-anthropic)
+ * emits the first three fields verbatim; local inference adds the
+ * `mtp_*` fields when speculative decoding is active. Callers that
+ * already handle the cloud `usage` shape need no change.
+ */
+export interface LocalUsageBlock {
+    [key: string]: unknown;
+    input_tokens: number;
+    output_tokens: number;
+    cache_creation_input_tokens: number;
+    cache_read_input_tokens: number;
+    mtp_drafted_tokens?: number;
+    mtp_accepted_tokens?: number;
+    /** 0..1 — proportion of drafted tokens that were accepted. */
+    mtp_acceptance_rate?: number;
+    /** 0..1 — proportion of input tokens that hit a warm slot (cache reuse). */
+    cache_hit_rate?: number;
+}
+/**
+ * Compute the Anthropic-shape usage block for a single generation by
+ * differencing two snapshots. `before` is taken just before the request,
+ * `after` just after the response was received. Negative deltas (caused
+ * by a metric reset between snapshots, e.g. server restart) are clamped
+ * to 0 — losing the sample is preferable to surfacing nonsense to the
+ * caller.
+ *
+ * Pass `responseUsage` to override input/output counts when the response
+ * payload itself reports per-call counters that are more accurate than
+ * the metric delta — llama-server's chat completion response includes
+ * `usage.{prompt,completion}_tokens` per request, which is exact while
+ * the metric delta is "everything that happened during the wall-clock
+ * window of the request."
+ */
+export declare function diffSnapshots(before: LlamaServerMetricSnapshot, after: LlamaServerMetricSnapshot, responseUsage?: {
+    prompt_tokens?: number;
+    completion_tokens?: number;
+}): LocalUsageBlock;
+/**
+ * GET `/metrics` from a running llama-server and parse it. Errors fall
+ * back to a zero-valued snapshot rather than throwing — observability
+ * MUST NOT break generation. `scrapeOk=false` tells callers that the
+ * zeros are not evidence of absent MTP/KV activity.
+ */
+export declare function fetchMetricsSnapshot(baseUrl: string, signal?: AbortSignal, timeoutMs?: number): Promise<LlamaServerMetricSnapshot>;
+//# sourceMappingURL=llama-server-metrics.d.ts.map

package/dist/services/llama-server-metrics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"llama-server-metrics.d.ts","sourceRoot":"","sources":["../../src/services/llama-server-metrics.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAEH,MAAM,WAAW,yBAAyB;IACzC,yEAAyE;IACzE,SAAS,EAAE,MAAM,CAAC;IAClB,+EAA+E;IAC/E,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,iFAAiF;IACjF,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC,iBAAiB,EAAE,MAAM,CAAC;IAC1B,oBAAoB,EAAE,MAAM,CAAC;IAC7B,2EAA2E;IAC3E,0BAA0B,EAAE,MAAM,CAAC;IACnC,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,4CAA4C;IAC5C,aAAa,EAAE,MAAM,CAAC;IACtB,2DAA2D;IAC3D,gBAAgB,EAAE,MAAM,CAAC;CACzB;AAuBD;;;;;;;;;;;;GAYG;AACH,wBAAgB,sBAAsB,CACrC,IAAI,EAAE,MAAM,EACZ,SAAS,GAAE,MAAmB,GAC5B,yBAAyB,CAuD3B;AAED;;;;;;GAMG;AACH,MAAM,WAAW,eAAe;IAC/B,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;IACvB,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,2BAA2B,EAAE,MAAM,CAAC;IACpC,uBAAuB,EAAE,MAAM,CAAC;IAChC,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,8DAA8D;IAC9D,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,4EAA4E;IAC5E,cAAc,CAAC,EAAE,MAAM,CAAC;CACxB;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,aAAa,CAC5B,MAAM,EAAE,yBAAyB,EACjC,KAAK,EAAE,yBAAyB,EAChC,aAAa,CAAC,EAAE;IAAE,aAAa,CAAC,EAAE,MAAM,CAAC;IAAC,iBAAiB,CAAC,EAAE,MAAM,CAAA;CAAE,GACpE,eAAe,CA2CjB;AAOD;;;;;GAKG;AACH,wBAAsB,oBAAoB,CACzC,OAAO,EAAE,MAAM,EACf,MAAM,CAAC,EAAE,WAAW,EACpB,SAAS,SAAoC,GAC3C,OAAO,CAAC,yBAAyB,CAAC,CAsDpC"}