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

package/dist/services/service.d.ts

@@ -0,0 +1,128 @@
+/**
+ * Public facade for the local-inference service.
+ *
+ * Single entry point used by the API routes, settings UI, and orchestration
+ * code. Holds singleton instances of the downloader
+ * and active-model coordinator so subscribers receive the same event
+ * stream across the process.
+ */
+import { type AgentRuntime } from "@elizaos/core";
+import { type LocalInferenceLoadOverrides } from "./active-model";
+import { MemoryArbiter } from "./memory-arbiter";
+import { type RecommendedModelSelection } from "./recommendation";
+import type { ActiveModelState, AgentModelSlot, CatalogModel, DownloadEvent, DownloadJob, HardwareProbe, LocalInferenceReadiness, ModelAssignments, ModelHubSnapshot, TextGenerationSlot } from "./types";
+import { type VerifyResult } from "./verify";
+export declare class LocalInferenceService {
+    private readonly downloader;
+    private readonly activeModel;
+    private bundledBootstrap;
+    /**
+     * Memory Arbiter (WS1). Lazily created on first access so the heavy
+     * pressure-source machinery doesn't run for processes that never load
+     * a local model (CI, dev shells, etc.). Once created, the arbiter is
+     * also published via `setMemoryArbiter` so cross-plugin consumers
+     * (plugin-vision, plugin-image-gen) can use `getMemoryArbiter()`.
+     */
+    private memoryArbiter;
+    /**
+     * Mobile pressure bridge — populated by the Capacitor host (iOS / Android
+     * onTrimMemory) so a native pressure callback can reach the arbiter.
+     * Stays null on desktop until WS2/WS8 wire the native side.
+     */
+    private mobilePressureBridge;
+    private imageGenCapabilityRegistered;
+    getCatalog(): CatalogModel[];
+    /**
+     * Register any bundled GGUF files staged by the AOSP build (or any
+     * other install path that drops a `manifest.json` next to the model
+     * files) into the registry. Runs at most once per process; the
+     * promise is cached so concurrent first callers wait on the same
+     * work.
+     */
+    private bootstrapBundled;
+    getInstalled(): Promise<import("@elizaos/shared").InstalledModel[]>;
+    getHardware(): Promise<HardwareProbe>;
+    getDownloads(): DownloadJob[];
+    getActive(): ActiveModelState;
+    getAssignments(): Promise<ModelAssignments>;
+    setSlotAssignment(slot: AgentModelSlot, modelId: string | null): Promise<ModelAssignments>;
+    snapshot(): Promise<ModelHubSnapshot>;
+    getTextReadiness(): Promise<LocalInferenceReadiness>;
+    getRecommendedModel(slot: TextGenerationSlot, hardware?: HardwareProbe): Promise<RecommendedModelSelection>;
+    getRecommendedModels(hardware?: HardwareProbe): Promise<Record<TextGenerationSlot, RecommendedModelSelection>>;
+    /**
+     * Kernel capability probing is now owned by the native FFI runtime. Null
+     * means "no static CAPABILITIES.json probe"; the dispatcher still enforces
+     * runtime-required kernels at load time.
+     */
+    private installedBinaryKernels;
+    startDownload(modelId: string): Promise<DownloadJob>;
+    startSmallerFallbackDownload(currentModelId: string, slot?: TextGenerationSlot, hardware?: HardwareProbe): Promise<{
+        model: CatalogModel;
+        job: DownloadJob;
+    } | null>;
+    searchHuggingFace(query: string, limit?: number): Promise<CatalogModel[]>;
+    searchModelHub(query: string, hub: "huggingface" | "modelscope", limit?: number): Promise<CatalogModel[]>;
+    /**
+     * Verify an installed model's file integrity. When the model was a
+     * Eliza-download and there was no stored sha256 yet (legacy entry), the
+     * computed hash is persisted so subsequent verifies have a baseline.
+     */
+    verifyModel(id: string): Promise<VerifyResult>;
+    cancelDownload(modelId: string): boolean;
+    subscribeDownloads(listener: (event: DownloadEvent) => void): () => void;
+    subscribeActive(listener: (state: ActiveModelState) => void): () => void;
+    setActive(runtime: AgentRuntime | null, modelId: string, overrides?: LocalInferenceLoadOverrides): Promise<ActiveModelState>;
+    prewarmActiveVoice(modelId: string): Promise<boolean>;
+    /**
+     * Warm the Stage-1 stable prefix after an explicit model activation.
+     *
+     * `ensureLocalInferenceHandler` also attempts this at runtime boot, but
+     * desktop activation often happens later through `/api/local-inference/active`;
+     * at boot there may be no resident model, so that early warmup correctly
+     * stays inactive. Running it here closes that gap without blocking activation.
+     */
+    prewarmSystemPrefix(runtime: AgentRuntime): Promise<boolean>;
+    clearActive(runtime: AgentRuntime | null): Promise<ActiveModelState>;
+    /**
+     * Diagnostic snapshot of the local prefix-cache state. Returns:
+     *   - `engine`: in-process session-pool size and live cache keys.
+     * Used by the API layer to render a "local cache" debug panel.
+     */
+    getLocalCacheStats(): Promise<{
+        engine: {
+            size: number;
+            maxSize: number;
+            keys: string[];
+        } | null;
+    }>;
+    /**
+     * Memory Arbiter (WS1). Returns the process-wide arbiter, creating it on
+     * first call. The arbiter is constructed against the engine's existing
+     * `SharedResourceRegistry` so eviction policy is consistent across the
+     * voice/text paths and the cross-plugin handles.
+     *
+     * The pressure source is a composite of:
+     *   - `nodeOsPressureSource()` — desktop polling at 5 s.
+     *   - A `capacitorPressureSource()` bridge — populated by the Capacitor
+     *     host on iOS/Android. The native side calls `dispatchMobilePressure`
+     *     when the OS hands it a memory-warning callback.
+     */
+    getMemoryArbiter(): MemoryArbiter;
+    private registerImageGenCapability;
+    private loadImageGenBackend;
+    private resolveImageGenLoadArgs;
+    private imageGenFileExists;
+    /**
+     * Capacitor bridge entrypoint. The mobile host (iOS / Android) calls
+     * this from the native pressure callback. Safe to call before the
+     * arbiter has been created — we create it on demand.
+     */
+    dispatchMobilePressure(level: "nominal" | "low" | "critical", freeMb?: number): void;
+    uninstall(modelId: string): Promise<{
+        removed: boolean;
+        reason?: "external" | "not-found";
+    }>;
+}
+export declare const localInferenceService: LocalInferenceService;
+//# sourceMappingURL=service.d.ts.map

package/dist/services/service.d.ts.map

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

package/dist/services/session-pool.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Session pool for the in-process node-llama-cpp engine.
+ *
+ * node-llama-cpp's `LlamaChatSession` keeps an internal KV cache. The
+ * stock engine code resets that cache between every turn, which is
+ * correct for stateless per-call generation but actively defeats prefix
+ * reuse for callers that pass a `promptCacheKey` (the runtime's
+ * cloud-style cache hint).
+ *
+ * This pool keeps one session per `promptCacheKey`, LRU-evicted, so
+ * sequential calls with the same key reuse the on-GPU/on-CPU KV cache.
+ * Calls without a cache key share the synthetic `_default` slot, which
+ * preserves the previous "stateless per-call" semantics by resetting
+ * before each turn.
+ *
+ * The pool owns nothing at module scope; the engine constructs a pool
+ * tied to the loaded model and disposes it on unload.
+ */
+export interface PoolSession {
+    /** Reset accumulated chat history. Called for the default slot only. */
+    resetChatHistory?(): void | Promise<void>;
+    /** Dispose underlying KV state. Called on eviction + on pool close. */
+    dispose?(): void | Promise<void>;
+}
+export type SessionFactory<TSession extends PoolSession> = (key: string) => Promise<TSession>;
+/**
+ * Synthetic key used for callers that didn't supply a `promptCacheKey`.
+ * These callers want the old "history-free" behaviour, so the engine
+ * resets chat history each turn for this slot only.
+ */
+export declare const DEFAULT_SESSION_KEY = "_default";
+export declare class SessionPool<TSession extends PoolSession> {
+    private readonly maxSize;
+    private readonly factory;
+    /**
+     * Insertion order = LRU order. We re-key on each access so the most
+     * recently used entry is always last in iteration order.
+     */
+    private readonly entries;
+    constructor(args: {
+        maxSize: number;
+        factory: SessionFactory<TSession>;
+    });
+    /**
+     * Get-or-create the session for `key`. Promotes the entry to MRU.
+     * On eviction, the oldest entry's `dispose()` is awaited before the
+     * new entry is returned so the caller never holds two live sessions
+     * over the same KV memory.
+     */
+    acquire(key: string): Promise<TSession>;
+    /** Number of live sessions, for diagnostics. */
+    size(): number;
+    /** Snapshot of live keys ordered LRU → MRU. */
+    keys(): string[];
+    /**
+     * Drop a single session by key. Used when the caller knows the prefix
+     * has gone stale (e.g. system prompt changed) and the cached KV is no
+     * longer valid.
+     */
+    drop(key: string): Promise<void>;
+    /**
+     * Tear down every cached session. Called by the engine on model
+     * unload. After `close()` the pool is empty but reusable.
+     */
+    close(): Promise<void>;
+    private disposeQuietly;
+}
+/**
+ * Resolve the pool size from env, with a sane default. Bound by 1..64.
+ */
+export declare function resolveDefaultPoolSize(envValue?: string | null): number;
+//# sourceMappingURL=session-pool.d.ts.map

package/dist/services/session-pool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-pool.d.ts","sourceRoot":"","sources":["../../src/services/session-pool.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,MAAM,WAAW,WAAW;IAC3B,wEAAwE;IACxE,gBAAgB,CAAC,IAAI,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1C,uEAAuE;IACvE,OAAO,CAAC,IAAI,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACjC;AAED,MAAM,MAAM,cAAc,CAAC,QAAQ,SAAS,WAAW,IAAI,CAC1D,GAAG,EAAE,MAAM,KACP,OAAO,CAAC,QAAQ,CAAC,CAAC;AASvB;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,aAAa,CAAC;AAE9C,qBAAa,WAAW,CAAC,QAAQ,SAAS,WAAW;IACpD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA2B;IACnD;;;OAGG;IACH,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAsC;gBAElD,IAAI,EAAE;QACjB,OAAO,EAAE,MAAM,CAAC;QAChB,OAAO,EAAE,cAAc,CAAC,QAAQ,CAAC,CAAC;KAClC;IAUD;;;;;OAKG;IACG,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,CAAC;IA0B7C,gDAAgD;IAChD,IAAI,IAAI,MAAM;IAId,+CAA+C;IAC/C,IAAI,IAAI,MAAM,EAAE;IAIhB;;;;OAIG;IACG,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAOtC;;;OAGG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;YAQd,cAAc;CAS5B;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,CAMvE"}

package/dist/services/structured-output/deterministic-repair.d.ts

@@ -0,0 +1,23 @@
+import type { JSONSchema, ResponseSkeleton } from "@elizaos/core";
+export type StructuredOutputRepairStatus = "unchanged" | "repaired" | "ambiguous" | "invalid";
+export interface StructuredOutputRepairOptions {
+    skeleton?: ResponseSkeleton;
+    jsonSchema?: JSONSchema;
+    jsonSchemasByKey?: Readonly<Record<string, JSONSchema | undefined>>;
+}
+export interface StructuredOutputRepairResult {
+    text: string;
+    status: StructuredOutputRepairStatus;
+    reason?: string;
+}
+export declare function repairStructuredOutput(text: string, options: StructuredOutputRepairOptions): StructuredOutputRepairResult;
+export declare class StructuredOutputRepairStream {
+    private readonly options;
+    private text;
+    private syntheticTail;
+    constructor(options: StructuredOutputRepairOptions);
+    push(chunk: string): string;
+    flush(): string;
+    currentText(): string;
+}
+//# sourceMappingURL=deterministic-repair.d.ts.map

package/dist/services/structured-output/deterministic-repair.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deterministic-repair.d.ts","sourceRoot":"","sources":["../../../src/services/structured-output/deterministic-repair.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACX,UAAU,EACV,gBAAgB,EAEhB,MAAM,eAAe,CAAC;AAEvB,MAAM,MAAM,4BAA4B,GACrC,WAAW,GACX,UAAU,GACV,WAAW,GACX,SAAS,CAAC;AAEb,MAAM,WAAW,6BAA6B;IAC7C,QAAQ,CAAC,EAAE,gBAAgB,CAAC;IAC5B,UAAU,CAAC,EAAE,UAAU,CAAC;IACxB,gBAAgB,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,UAAU,GAAG,SAAS,CAAC,CAAC,CAAC;CACpE;AAED,MAAM,WAAW,4BAA4B;IAC5C,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,4BAA4B,CAAC;IACrC,MAAM,CAAC,EAAE,MAAM,CAAC;CAChB;AAuWD,wBAAgB,sBAAsB,CACrC,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,6BAA6B,GACpC,4BAA4B,CAa9B;AASD,qBAAa,4BAA4B;IAI5B,OAAO,CAAC,QAAQ,CAAC,OAAO;IAHpC,OAAO,CAAC,IAAI,CAAM;IAClB,OAAO,CAAC,aAAa,CAAM;gBAEE,OAAO,EAAE,6BAA6B;IAEnE,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;IAkB3B,KAAK,IAAI,MAAM;IASf,WAAW,IAAI,MAAM;CAGrB"}

package/dist/services/structured-output/index.d.ts

@@ -0,0 +1,2 @@
+export * from "../structured-output.ts";
+//# sourceMappingURL=index.d.ts.map

package/dist/services/structured-output/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/services/structured-output/index.ts"],"names":[],"mappings":"AAGA,cAAc,yBAAyB,CAAC"}

package/dist/services/structured-output.d.ts

@@ -0,0 +1,311 @@
+/**
+ * Structured-output / forced-span / prefill plumbing for the local-inference
+ * engine path.
+ *
+ * The canonical contract lives in `@elizaos/core` `GenerateTextParams`
+ * (`prefill`, `responseSkeleton`, `grammar`, `streamStructured`) and is
+ * threaded through `useModel` → router. This module is the
+ * local-inference-layer mirror of the relevant subset plus the GBNF
+ * compilation that turns a `ResponseSkeleton` into a *lazy* grammar so the
+ * model only ever samples the free positions of the response envelope
+ * (single-value enums collapse to literals — no tokens spent on the scaffold).
+ *
+ * Nothing here is local-model-specific in shape; cloud adapters never read
+ * these fields. There is no fallback path — adapters that can't honour
+ * `grammar` / `prefill` / `responseSkeleton` ignore them, full stop.
+ */
+import type { JSONSchema, ResponseSkeleton, ResponseSkeletonSpan, SpanSamplerPlan } from "@elizaos/core";
+export { repairStructuredOutput, type StructuredOutputRepairOptions, type StructuredOutputRepairResult, type StructuredOutputRepairStatus, StructuredOutputRepairStream, } from "./structured-output/deterministic-repair";
+export type { ResponseSkeleton, ResponseSkeletonSpan, SpanSamplerPlan };
+/**
+ * GBNF grammar fragment ready for a llama-server request body. `lazy` grammars
+ * only kick in once a trigger word/sequence appears in the stream
+ * (llama.cpp's `grammar_lazy` + `grammar_triggers`) — that lets the model
+ * free-run the prose `replyText` and only constrain the structured scaffold
+ * once the envelope boundary is reached.
+ */
+export interface GbnfGrammar {
+    /** GBNF source. */
+    source: string;
+    /** When true, the server applies the grammar lazily (`grammar_lazy: true`). */
+    lazy?: boolean;
+    /** Trigger words that activate a lazy grammar (`grammar_triggers`). */
+    triggers?: ReadonlyArray<string>;
+}
+/**
+ * Local-inference mirror of the structured-output extensions on
+ * `GenerateTextParams`. Threaded `useModel` → router → local handler →
+ * engine → FFI runtime.
+ */
+export interface StructuredGenerateParams {
+    /**
+     * Assistant-turn prefill — a partial assistant message the model should
+     * *continue* rather than start fresh. On llama-server this is sent as a
+     * trailing assistant message with `continue_final_message` / the
+     * `assistant` chat-template prefix; the capacitor-llama path seeds the
+     * prompt text and re-prepends the prefill to the result.
+     */
+    prefill?: string;
+    /**
+     * Forced response skeleton. When set the engine compiles it to a lazy GBNF
+     * (single-value enums → literals) so the model only samples the free
+     * positions of the envelope.
+     */
+    responseSkeleton?: ResponseSkeleton;
+    /** Optional whole-response JSON schema from `GenerateTextParams`. */
+    responseSchema?: JSONSchema;
+    /**
+     * Explicit GBNF grammar string. When both `grammar` and `responseSkeleton`
+     * are present, the explicit `grammar` wins.
+     */
+    grammar?: string;
+    /**
+     * When true, the engine streams per-token chunks back via `onTextChunk`
+     * (and structured-field events) instead of returning the whole string in
+     * one shot.
+     */
+    streamStructured?: boolean;
+    /**
+     * The eliza harness schema for this call — the compact descriptor bundling
+     * the response skeleton, a pre-built grammar (optional), the derived
+     * deterministic-token {@link ElizaPrefillPlan}, and the short/long name maps.
+     * When present, guided structured decode is *on* for this call: the engine
+     * sends the grammar AND the prefill plan, and seeds the leading literal run
+     * as an assistant-turn prefill. Absent → guided decode is off (the engine
+     * may still honour a bare `grammar` / `responseSkeleton`, but never emits a
+     * prefill plan). This is the off-by-default switch for the deterministic
+     * short-circuit.
+     */
+    elizaSchema?: ElizaHarnessSchema;
+    /**
+     * Per-span sampler overrides for the {@link responseSkeleton}. When set,
+     * the engine emits `eliza_span_samplers` on the llama-server request body so
+     * the fork-side server swaps to argmax (`llama_sampler_init_greedy()`) at
+     * the indicated enum / number / boolean positions. Stock llama-server
+     * ignores the field — the grammar still constrains the same tokens, we
+     * just lose the argmax determinism guarantee on that path.
+     *
+     * Producer: `@elizaos/core` `buildSpanSamplerPlan(skeleton)`.
+     */
+    spanSamplerPlan?: SpanSamplerPlan;
+    /**
+     * Per-request chat-template thinking control for reasoning-capable local
+     * models. `off` maps to `chat_template_kwargs.enable_thinking=false` for
+     * response-handler/direct-reply calls that must emit user-visible text, while
+     * planner/action calls can omit this and use the catalog/server default.
+     */
+    thinking?: "auto" | "on" | "off";
+}
+/**
+ * Collapse a skeleton: `enum` spans with exactly one value (or zero values)
+ * become `literal` spans (C4). Adjacent literals stay separate spans — the
+ * compiler merges them in the root rule.
+ */
+export declare function collapseSkeleton(skeleton: ResponseSkeleton): ResponseSkeleton;
+/**
+ * Compile a `ResponseSkeleton` to a *lazy* GBNF grammar. The grammar's `root`
+ * rule is the concatenation of every span:
+ *   - `literal` spans → GBNF string literals (the JSON key/glue scaffold),
+ *   - `enum` spans (≥2 values) → an alternation of quoted-string literals,
+ *   - `free-string` spans → a quoted JSON string rule,
+ *   - `free-json` spans → the recursive JSON-value rule.
+ *
+ * The grammar runs *lazily* when the skeleton opens with a literal (the
+ * trigger word) — generation free-runs until that literal is seen, then the
+ * grammar pins the rest of the envelope. That keeps the prose prefix
+ * unconstrained while forcing the JSON scaffold.
+ *
+ * Returns `null` when the skeleton has no free spans (nothing for the model to
+ * sample — the caller should just emit the literal text and skip generation).
+ */
+export declare function compileSkeletonToGbnf(skeletonInput: ResponseSkeleton): GbnfGrammar | null;
+/**
+ * Resolve the GBNF grammar to apply for a generation call. Precedence: an
+ * explicit `grammar` string on the params, then a compiled `responseSkeleton`.
+ * Returns null when neither is set.
+ */
+export declare function resolveGrammarForParams(params: StructuredGenerateParams | undefined): GbnfGrammar | null;
+/**
+ * Build the OpenAI-/llama-server-compatible request-body fragment for a
+ * grammar. Returns `grammar` + (when lazy) `grammar_lazy` / `grammar_triggers`.
+ * Recent llama.cpp accepts these on both `/v1/chat/completions` and
+ * `/completion`.
+ */
+export declare function grammarRequestFields(grammar: GbnfGrammar): Record<string, unknown>;
+/**
+ * Split a skeleton's leading literal run off as an assistant-turn prefill
+ * candidate, returning that prefix plus the remaining spans. Used by the
+ * multi-call infill fallback (emit prefix as a prefill, generate the first
+ * free span, then loop).
+ */
+export declare function splitSkeletonAtFirstFree(skeleton: ResponseSkeleton): {
+    prefixLiteral: string;
+    rest: ResponseSkeletonSpan[];
+};
+/**
+ * One deterministically-forced byte run in an {@link ElizaPrefillPlan}. The
+ * runs alternate with the free (sampled) spans, so a run is unambiguously
+ * anchored by *position* in that alternation rather than by an absolute byte
+ * offset (the sampled spans have unknown length at plan time):
+ *
+ *   run[0]  free[0]  run[1]  free[1]  …  run[n]   (n = number of free spans)
+ *
+ * `afterFreeSpan` is `-1` for the leading run (before any free span — the
+ * assistant-turn prefill), then `0, 1, 2, …` for the run that follows free
+ * span 0, 1, 2, … . The server resumes sampling after writing each run; once
+ * the matching free span is sampled it writes the next run's token ids without
+ * a forward pass and advances the decoder to the next free span.
+ */
+export interface PrefillRun {
+    /**
+     * Index of the free span this run *follows*. `-1` = the leading run (the
+     * prefill); `k >= 0` = the run after free span `k`. The last run (`n`) is the
+     * tail scaffold (closing braces) after the final free span.
+     */
+    afterFreeSpan: number;
+    /** The deterministically-forced bytes. */
+    text: string;
+    /**
+     * Optional pre-tokenized token IDs for this run. When provided at compile time
+     * via a tokenizer callback, the FFI runtime can use these directly without
+     * re-tokenizing, improving latency.
+     */
+    tokenIds?: number[];
+}
+/**
+ * Compact descriptor of the deterministic structure of a constrained decode:
+ * the ordered runs of bytes that are fixed (so the server can prefill their
+ * token ids and skip the forward passes) interleaved with the count of free
+ * positions, plus the leading literal run that should be seeded as an
+ * assistant-turn prefill (`prefix`). Sent on the request as `eliza_prefill_plan`.
+ *
+ * Purely a speedup hint — a server that ignores it produces the identical
+ * output because the lazy GBNF already forces the same bytes.
+ */
+export interface ElizaPrefillPlan {
+    /**
+     * The leading deterministic run — emitted as an assistant-turn prefill so
+     * the model never samples it. Empty when the skeleton opens with a free span.
+     */
+    prefix: string;
+    /**
+     * Deterministic byte runs alternating with the free spans (see
+     * {@link PrefillRun}), in output order, including the prefix run when
+     * non-empty.
+     */
+    runs: PrefillRun[];
+    /** Number of free (sampled) spans in the skeleton. `runs.length` is `freeCount + 1` minus the leading run when the skeleton starts free. */
+    freeCount: number;
+    /**
+     * Opaque cache key (mirrors the skeleton's `id`) so the server can cache the
+     * tokenised form of the runs across turns when the structure is unchanged.
+     */
+    id?: string;
+}
+/**
+ * Compute the {@link ElizaPrefillPlan} for a response skeleton: walk the spans,
+ * accumulating consecutive `literal` spans (and single-value enums collapsed to
+ * literals) into deterministic byte runs and counting the free spans. Adjacent
+ * literals merge into one run. Returns `null` when the skeleton has no
+ * deterministic runs at all (nothing to prefill).
+ *
+ * Invariant the consumer relies on: concatenating the runs interleaved with the
+ * (eventually-sampled) free-span values, in order, reproduces a byte-identical
+ * JSON document to what the lazy GBNF from {@link compileSkeletonToGbnf} would
+ * have produced. The tests assert this.
+ */
+export declare function compilePrefillPlan(skeletonInput: ResponseSkeleton, tokenize?: (text: string) => number[]): ElizaPrefillPlan | null;
+/**
+ * Build the request-body fragment carrying the prefill plan. The server reads
+ * `eliza_prefill_plan` (a tolerant extension — old binaries ignore it and the
+ * grammar still forces the same bytes). Returns `{}` when there is no plan.
+ */
+export declare function prefillPlanRequestFields(plan: ElizaPrefillPlan | null): Record<string, unknown>;
+/**
+ * Build the request-body fragment carrying per-span sampler overrides. The
+ * fork-side llama-server reads `eliza_span_samplers` (a tolerant extension —
+ * old binaries ignore it; the grammar still constrains the same tokens, we
+ * just lose the per-span argmax determinism guarantee on the legacy path).
+ *
+ * Wire schema (snake_case for OpenAI body conventions):
+ *   {
+ *     overrides: [
+ *       { span_index: number, temperature: number, top_k?: number, top_p?: number }
+ *     ],
+ *     strict?: boolean
+ *   }
+ *
+ * Returns `{}` when there is no plan or no overrides — keep the wire surface
+ * narrow so a stock server never has to skip past empty fork extensions.
+ */
+export declare function spanSamplerPlanRequestFields(plan: SpanSamplerPlan | undefined | null): Record<string, unknown>;
+/**
+ * The compact, engine-facing descriptor for a structured output the agent loop
+ * wants forced. It is the bundle of (a) a {@link ResponseSkeleton} (which
+ * compiles to a lazy GBNF for the constrained-decode path), (b) the derived
+ * {@link ElizaPrefillPlan} (the deterministic-token short-circuit), and (c) the
+ * short-name ↔ long-name maps so the on-wire/decoded form uses canonical short
+ * action ids / enum values and the runtime expands them for the caller.
+ *
+ * Producers: `@elizaos/core` `buildPlannerActionGrammar` / `buildResponseGrammar`
+ * wrapped by {@link elizaHarnessSchemaFromSkeleton}. Consumer: the local engine
+ * (`ffi-streaming-backend.ts` / `engine.ts`).
+ */
+export interface ElizaHarnessSchema {
+    /** Structure-forcing description; compiles to a lazy GBNF. */
+    skeleton: ResponseSkeleton;
+    /** Pre-built GBNF (wins over compiling the skeleton), when the producer made one. */
+    grammar?: string;
+    /** Deterministic-token short-circuit derived from the skeleton. */
+    prefillPlan: ElizaPrefillPlan | null;
+    /**
+     * Canonical short id → human-facing long name (display label), for any
+     * closed enum the descriptor pins (action ids, known enum values). The wire
+     * form is the short id; callers that want the long name look it up here.
+     * Empty when nothing needs expanding.
+     */
+    longNames: Record<string, string>;
+    /** Cache key (the skeleton's id). */
+    id?: string;
+}
+/**
+ * Wrap a {@link ResponseSkeleton} (+ optional pre-built grammar + name map)
+ * into an {@link ElizaHarnessSchema}, computing the prefill plan. This is the
+ * single place the prefill plan is derived so producers don't each reimplement
+ * it.
+ */
+export declare function elizaHarnessSchemaFromSkeleton(input: {
+    skeleton: ResponseSkeleton;
+    grammar?: string;
+    longNames?: Record<string, string>;
+    tokenize?: (text: string) => number[];
+}): ElizaHarnessSchema;
+/**
+ * Expand a canonical short id decoded out of a constrained generation back to
+ * its human-facing long name (display label), using the descriptor's
+ * {@link ElizaHarnessSchema.longNames} map (sourced from the action catalog).
+ * Identity when there is no mapping — the canonical action ids
+ * (`normalizeActionName` results, e.g. `SEND_MESSAGE`) are already the on-wire
+ * form, so this is only meaningful when a producer registered a separate
+ * display label.
+ */
+export declare function expandShortName(schema: ElizaHarnessSchema | undefined, shortId: string): string;
+/**
+ * Invert {@link expandShortName}: given a (possibly long) name the caller
+ * supplied, return the canonical short id the wire form expects. Identity when
+ * the name is already a known short id or no mapping matches.
+ */
+export declare function canonicalizeShortName(schema: ElizaHarnessSchema | undefined, name: string): string;
+/**
+ * Resolve the GBNF + prefill plan + assistant-turn prefill to apply for a
+ * generation call given the structured params. Precedence for the grammar:
+ * an explicit `grammar` string, then a harness schema's `grammar`, then
+ * compiling the harness schema's / params' `responseSkeleton`. The prefill plan
+ * is only present when a harness schema is supplied (off by default).
+ */
+export declare function resolveGuidedDecodeForParams(params: StructuredGenerateParams | undefined): {
+    grammar: GbnfGrammar | null;
+    prefillPlan: ElizaPrefillPlan | null;
+    prefill: string | null;
+};
+//# sourceMappingURL=structured-output.d.ts.map

package/dist/services/structured-output.d.ts.map

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

package/dist/services/system-memory.d.ts

@@ -0,0 +1,33 @@
+/**
+ * System memory reader — the single source of "how much RAM can we actually
+ * allocate right now" for the local-inference memory arbiter and pressure
+ * sources.
+ *
+ * Node's `os.freemem()` returns the kernel's `MemFree` on Linux, which counts
+ * only never-touched pages and EXCLUDES reclaimable page cache + slab. On
+ * Android — where the app process runs under a large page cache — `MemFree`
+ * undercounts allocatable memory by gigabytes, so a `MemFree`-driven arbiter
+ * evicts models it didn't need to and refuses loads that would have fit.
+ *
+ * `/proc/meminfo`'s `MemAvailable` is the kernel's own estimate of how much
+ * memory is available for starting new applications without swapping (free +
+ * reclaimable cache/slab, minus the low watermark). That is exactly the number
+ * the arbiter wants. Read it on Linux/Android; fall back to `os.freemem()` /
+ * `os.totalmem()` everywhere else (macOS, Windows) or if `/proc/meminfo` is
+ * unreadable or pre-3.14 (no `MemAvailable`).
+ */
+export interface SystemMemory {
+    freeBytes: number;
+    totalBytes: number;
+}
+/** Injectable for tests: returns the raw `/proc/meminfo` text, or null. */
+export type MeminfoReader = () => string | null;
+/**
+ * Read available + total system memory in bytes. Prefers `/proc/meminfo`
+ * `MemAvailable`/`MemTotal` on Linux; falls back to `os.freemem()/totalmem()`.
+ *
+ * @param read injectable meminfo reader (tests). Defaults to reading
+ *   `/proc/meminfo` on Linux and returning null elsewhere.
+ */
+export declare function readSystemMemory(read?: MeminfoReader): SystemMemory;
+//# sourceMappingURL=system-memory.d.ts.map

package/dist/services/system-memory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"system-memory.d.ts","sourceRoot":"","sources":["../../src/services/system-memory.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAKH,MAAM,WAAW,YAAY;IAC5B,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;CACnB;AAED,2EAA2E;AAC3E,MAAM,MAAM,aAAa,GAAG,MAAM,MAAM,GAAG,IAAI,CAAC;AAmBhD;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC/B,IAAI,GAAE,aAAoC,GACxC,YAAY,CAUd"}

package/dist/services/types.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Local inference type re-exports.
+ *
+ * The canonical definitions live in `@elizaos/shared/local-inference`.
+ * This shim preserves the historical import path
+ * `../services/local-inference/types` for server-side code.
+ */
+export { type ActiveModelState, AGENT_MODEL_SLOTS, type AgentModelSlot, type CatalogModel, type CatalogQuantizationId, type CatalogQuantizationMatrix, type CatalogQuantizationVariant, type CpuFeatureProbe, classifyCatalogModelRuntimeClass, classifyInstalledModelRuntimeClass, type DownloadEvent, type DownloadJob, type DownloadState, type GpuProfile, type GpuProfileId, type HardwareFitLevel, type HardwareProbe, type InstalledModel, type KvCacheType, type LocalInferenceDownloadStatus, type LocalInferenceReadiness, type LocalInferenceSlotReadiness, type LocalRuntimeAcceleration, type LocalRuntimeBackend, type LocalRuntimeKernel, type LocalRuntimeOptimizations, type MobileHardwareProbe, type ModelAssignments, type ModelBucket, type ModelCategory, type ModelHubSnapshot, type OpenVinoDeviceKind, type OpenVinoHardwareProbe, type RuntimeClass, TEXT_GENERATION_SLOTS, type TextGenerationSlot, type TokenizerFamily, withRuntimeClass, } from "@elizaos/shared";
+/** RAM requirements for a model bundle. */
+export interface RamBudget {
+    /** Minimum RAM the bundle will boot under, in megabytes. */
+    minMb: number;
+    /** RAM the bundle expects for nominal workloads, in megabytes. */
+    recommendedMb: number;
+    /** Where the numbers came from. `manifest` only when both came from
+     *  a validated `eliza-1.manifest.json` next to the installed bundle. */
+    source: "manifest" | "catalog";
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/services/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/services/types.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EACN,KAAK,gBAAgB,EACrB,iBAAiB,EACjB,KAAK,cAAc,EACnB,KAAK,YAAY,EACjB,KAAK,qBAAqB,EAC1B,KAAK,yBAAyB,EAC9B,KAAK,0BAA0B,EAC/B,KAAK,eAAe,EACpB,gCAAgC,EAChC,kCAAkC,EAClC,KAAK,aAAa,EAClB,KAAK,WAAW,EAChB,KAAK,aAAa,EAClB,KAAK,UAAU,EACf,KAAK,YAAY,EACjB,KAAK,gBAAgB,EACrB,KAAK,aAAa,EAClB,KAAK,cAAc,EACnB,KAAK,WAAW,EAChB,KAAK,4BAA4B,EACjC,KAAK,uBAAuB,EAC5B,KAAK,2BAA2B,EAChC,KAAK,wBAAwB,EAC7B,KAAK,mBAAmB,EACxB,KAAK,kBAAkB,EACvB,KAAK,yBAAyB,EAC9B,KAAK,mBAAmB,EACxB,KAAK,gBAAgB,EACrB,KAAK,WAAW,EAChB,KAAK,aAAa,EAClB,KAAK,gBAAgB,EACrB,KAAK,kBAAkB,EACvB,KAAK,qBAAqB,EAC1B,KAAK,YAAY,EACjB,qBAAqB,EACrB,KAAK,kBAAkB,EACvB,KAAK,eAAe,EACpB,gBAAgB,GAChB,MAAM,iBAAiB,CAAC;AAEzB,2CAA2C;AAC3C,MAAM,WAAW,SAAS;IACzB,4DAA4D;IAC5D,KAAK,EAAE,MAAM,CAAC;IACd,kEAAkE;IAClE,aAAa,EAAE,MAAM,CAAC;IACtB;4EACwE;IACxE,MAAM,EAAE,UAAU,GAAG,SAAS,CAAC;CAC/B"}