@elizaos/app-core 2.0.0-beta.3 → 2.0.11-beta.6

package/services/local-inference/manifest/schema.d.ts

@@ -1,419 +0,0 @@
-import { z } from "zod";
-export declare const ELIZA_1_MANIFEST_SCHEMA_VERSION: "1";
-export declare const ELIZA_1_MANIFEST_SCHEMA_URL: "https://elizalabs.ai/schemas/eliza-1.manifest.v1.json";
-export declare const ELIZA_1_TIERS: readonly ["lite-0_6b", "mobile-1_7b", "desktop-9b", "pro-27b", "server-h200"];
-export type Eliza1Tier = (typeof ELIZA_1_TIERS)[number];
-export declare const ELIZA_1_KERNELS: readonly ["turboquant_q3", "turboquant_q4", "qjl", "polarquant", "dflash", "turbo3_tcq"];
-export type Eliza1Kernel = (typeof ELIZA_1_KERNELS)[number];
-export declare const ELIZA_1_BACKENDS: readonly ["metal", "vulkan", "cuda", "cpu"];
-export type Eliza1Backend = (typeof ELIZA_1_BACKENDS)[number];
-export declare const REQUIRED_KERNELS_BY_TIER: Readonly<Record<Eliza1Tier, ReadonlyArray<Eliza1Kernel>>>;
-export declare const SUPPORTED_BACKENDS_BY_TIER: Readonly<Record<Eliza1Tier, ReadonlyArray<Eliza1Backend>>>;
-export declare const Eliza1LineageSchema: z.ZodObject<{
-    text: z.ZodObject<{
-        base: z.ZodString;
-        license: z.ZodString;
-    }, z.core.$strip>;
-    voice: z.ZodObject<{
-        base: z.ZodString;
-        license: z.ZodString;
-    }, z.core.$strip>;
-    drafter: z.ZodObject<{
-        base: z.ZodString;
-        license: z.ZodString;
-    }, z.core.$strip>;
-    asr: z.ZodOptional<z.ZodObject<{
-        base: z.ZodString;
-        license: z.ZodString;
-    }, z.core.$strip>>;
-    embedding: z.ZodOptional<z.ZodObject<{
-        base: z.ZodString;
-        license: z.ZodString;
-    }, z.core.$strip>>;
-    vision: z.ZodOptional<z.ZodObject<{
-        base: z.ZodString;
-        license: z.ZodString;
-    }, z.core.$strip>>;
-    vad: z.ZodOptional<z.ZodObject<{
-        base: z.ZodString;
-        license: z.ZodString;
-    }, z.core.$strip>>;
-    wakeword: z.ZodOptional<z.ZodObject<{
-        base: z.ZodString;
-        license: z.ZodString;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-export declare const Eliza1FileEntrySchema: z.ZodObject<{
-    path: z.ZodString;
-    sha256: z.ZodString;
-    ctx: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>;
-export declare const Eliza1FilesSchema: z.ZodObject<{
-    text: z.ZodArray<z.ZodObject<{
-        path: z.ZodString;
-        sha256: z.ZodString;
-        ctx: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>>;
-    voice: z.ZodArray<z.ZodObject<{
-        path: z.ZodString;
-        sha256: z.ZodString;
-        ctx: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>>;
-    asr: z.ZodArray<z.ZodObject<{
-        path: z.ZodString;
-        sha256: z.ZodString;
-        ctx: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>>;
-    vision: z.ZodArray<z.ZodObject<{
-        path: z.ZodString;
-        sha256: z.ZodString;
-        ctx: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>>;
-    dflash: z.ZodArray<z.ZodObject<{
-        path: z.ZodString;
-        sha256: z.ZodString;
-        ctx: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>>;
-    cache: z.ZodArray<z.ZodObject<{
-        path: z.ZodString;
-        sha256: z.ZodString;
-        ctx: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>>;
-    embedding: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        path: z.ZodString;
-        sha256: z.ZodString;
-        ctx: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>>>;
-    vad: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        path: z.ZodString;
-        sha256: z.ZodString;
-        ctx: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>>>;
-    wakeword: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        path: z.ZodString;
-        sha256: z.ZodString;
-        ctx: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>>>;
-}, z.core.$strip>;
-export declare const Eliza1KernelEnumSchema: z.ZodEnum<{
-    dflash: "dflash";
-    turboquant_q3: "turboquant_q3";
-    turboquant_q4: "turboquant_q4";
-    qjl: "qjl";
-    polarquant: "polarquant";
-    turbo3_tcq: "turbo3_tcq";
-}>;
-export declare const Eliza1BackendEnumSchema: z.ZodEnum<{
-    metal: "metal";
-    vulkan: "vulkan";
-    cuda: "cuda";
-    cpu: "cpu";
-}>;
-export declare const Eliza1TierEnumSchema: z.ZodEnum<{
-    "lite-0_6b": "lite-0_6b";
-    "mobile-1_7b": "mobile-1_7b";
-    "desktop-9b": "desktop-9b";
-    "pro-27b": "pro-27b";
-    "server-h200": "server-h200";
-}>;
-export declare const Eliza1VerifiedBackendStatusSchema: z.ZodObject<{
-    status: z.ZodEnum<{
-        pass: "pass";
-        fail: "fail";
-        skipped: "skipped";
-    }>;
-    atCommit: z.ZodString;
-    report: z.ZodString;
-}, z.core.$strip>;
-export declare const Eliza1KernelsSchema: z.ZodObject<{
-    required: z.ZodArray<z.ZodEnum<{
-        dflash: "dflash";
-        turboquant_q3: "turboquant_q3";
-        turboquant_q4: "turboquant_q4";
-        qjl: "qjl";
-        polarquant: "polarquant";
-        turbo3_tcq: "turbo3_tcq";
-    }>>;
-    optional: z.ZodArray<z.ZodEnum<{
-        dflash: "dflash";
-        turboquant_q3: "turboquant_q3";
-        turboquant_q4: "turboquant_q4";
-        qjl: "qjl";
-        polarquant: "polarquant";
-        turbo3_tcq: "turbo3_tcq";
-    }>>;
-    verifiedBackends: z.ZodObject<{
-        metal: z.ZodObject<{
-            status: z.ZodEnum<{
-                pass: "pass";
-                fail: "fail";
-                skipped: "skipped";
-            }>;
-            atCommit: z.ZodString;
-            report: z.ZodString;
-        }, z.core.$strip>;
-        vulkan: z.ZodObject<{
-            status: z.ZodEnum<{
-                pass: "pass";
-                fail: "fail";
-                skipped: "skipped";
-            }>;
-            atCommit: z.ZodString;
-            report: z.ZodString;
-        }, z.core.$strip>;
-        cuda: z.ZodObject<{
-            status: z.ZodEnum<{
-                pass: "pass";
-                fail: "fail";
-                skipped: "skipped";
-            }>;
-            atCommit: z.ZodString;
-            report: z.ZodString;
-        }, z.core.$strip>;
-        cpu: z.ZodObject<{
-            status: z.ZodEnum<{
-                pass: "pass";
-                fail: "fail";
-                skipped: "skipped";
-            }>;
-            atCommit: z.ZodString;
-            report: z.ZodString;
-        }, z.core.$strip>;
-    }, z.core.$strip>;
-}, z.core.$strip>;
-export declare const ELIZA_1_VOICE_CAPABILITIES: readonly ["tts", "emotion-tags", "singing"];
-export type Eliza1VoiceCapability = (typeof ELIZA_1_VOICE_CAPABILITIES)[number];
-export declare const Eliza1VoiceSchema: z.ZodObject<{
-    capabilities: z.ZodDefault<z.ZodArray<z.ZodEnum<{
-        tts: "tts";
-        "emotion-tags": "emotion-tags";
-        singing: "singing";
-    }>>>;
-}, z.core.$strip>;
-export declare const Eliza1EvalsSchema: z.ZodObject<{
-    textEval: z.ZodObject<{
-        score: z.ZodNumber;
-        passed: z.ZodBoolean;
-    }, z.core.$strip>;
-    voiceRtf: z.ZodObject<{
-        rtf: z.ZodNumber;
-        passed: z.ZodBoolean;
-    }, z.core.$strip>;
-    e2eLoopOk: z.ZodBoolean;
-    thirtyTurnOk: z.ZodBoolean;
-    asrWer: z.ZodOptional<z.ZodObject<{
-        wer: z.ZodNumber;
-        passed: z.ZodBoolean;
-    }, z.core.$strip>>;
-    embedMteb: z.ZodOptional<z.ZodObject<{
-        score: z.ZodNumber;
-        passed: z.ZodBoolean;
-    }, z.core.$strip>>;
-    vadLatencyMs: z.ZodOptional<z.ZodObject<{
-        median: z.ZodNumber;
-        passed: z.ZodBoolean;
-    }, z.core.$strip>>;
-    expressive: z.ZodOptional<z.ZodObject<{
-        tagFaithfulness: z.ZodNumber;
-        mosExpressive: z.ZodNumber;
-        tagLeakage: z.ZodNumber;
-        passed: z.ZodBoolean;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-export declare const Eliza1RamBudgetSchema: z.ZodObject<{
-    min: z.ZodNumber;
-    recommended: z.ZodNumber;
-}, z.core.$strip>;
-export declare const Eliza1ManifestSchema: z.ZodObject<{
-    $schema: z.ZodOptional<z.ZodLiteral<"https://elizalabs.ai/schemas/eliza-1.manifest.v1.json">>;
-    id: z.ZodString;
-    tier: z.ZodEnum<{
-        "lite-0_6b": "lite-0_6b";
-        "mobile-1_7b": "mobile-1_7b";
-        "desktop-9b": "desktop-9b";
-        "pro-27b": "pro-27b";
-        "server-h200": "server-h200";
-    }>;
-    version: z.ZodString;
-    publishedAt: z.ZodString;
-    lineage: z.ZodObject<{
-        text: z.ZodObject<{
-            base: z.ZodString;
-            license: z.ZodString;
-        }, z.core.$strip>;
-        voice: z.ZodObject<{
-            base: z.ZodString;
-            license: z.ZodString;
-        }, z.core.$strip>;
-        drafter: z.ZodObject<{
-            base: z.ZodString;
-            license: z.ZodString;
-        }, z.core.$strip>;
-        asr: z.ZodOptional<z.ZodObject<{
-            base: z.ZodString;
-            license: z.ZodString;
-        }, z.core.$strip>>;
-        embedding: z.ZodOptional<z.ZodObject<{
-            base: z.ZodString;
-            license: z.ZodString;
-        }, z.core.$strip>>;
-        vision: z.ZodOptional<z.ZodObject<{
-            base: z.ZodString;
-            license: z.ZodString;
-        }, z.core.$strip>>;
-        vad: z.ZodOptional<z.ZodObject<{
-            base: z.ZodString;
-            license: z.ZodString;
-        }, z.core.$strip>>;
-        wakeword: z.ZodOptional<z.ZodObject<{
-            base: z.ZodString;
-            license: z.ZodString;
-        }, z.core.$strip>>;
-    }, z.core.$strip>;
-    files: z.ZodObject<{
-        text: z.ZodArray<z.ZodObject<{
-            path: z.ZodString;
-            sha256: z.ZodString;
-            ctx: z.ZodOptional<z.ZodNumber>;
-        }, z.core.$strip>>;
-        voice: z.ZodArray<z.ZodObject<{
-            path: z.ZodString;
-            sha256: z.ZodString;
-            ctx: z.ZodOptional<z.ZodNumber>;
-        }, z.core.$strip>>;
-        asr: z.ZodArray<z.ZodObject<{
-            path: z.ZodString;
-            sha256: z.ZodString;
-            ctx: z.ZodOptional<z.ZodNumber>;
-        }, z.core.$strip>>;
-        vision: z.ZodArray<z.ZodObject<{
-            path: z.ZodString;
-            sha256: z.ZodString;
-            ctx: z.ZodOptional<z.ZodNumber>;
-        }, z.core.$strip>>;
-        dflash: z.ZodArray<z.ZodObject<{
-            path: z.ZodString;
-            sha256: z.ZodString;
-            ctx: z.ZodOptional<z.ZodNumber>;
-        }, z.core.$strip>>;
-        cache: z.ZodArray<z.ZodObject<{
-            path: z.ZodString;
-            sha256: z.ZodString;
-            ctx: z.ZodOptional<z.ZodNumber>;
-        }, z.core.$strip>>;
-        embedding: z.ZodOptional<z.ZodArray<z.ZodObject<{
-            path: z.ZodString;
-            sha256: z.ZodString;
-            ctx: z.ZodOptional<z.ZodNumber>;
-        }, z.core.$strip>>>;
-        vad: z.ZodOptional<z.ZodArray<z.ZodObject<{
-            path: z.ZodString;
-            sha256: z.ZodString;
-            ctx: z.ZodOptional<z.ZodNumber>;
-        }, z.core.$strip>>>;
-        wakeword: z.ZodOptional<z.ZodArray<z.ZodObject<{
-            path: z.ZodString;
-            sha256: z.ZodString;
-            ctx: z.ZodOptional<z.ZodNumber>;
-        }, z.core.$strip>>>;
-    }, z.core.$strip>;
-    kernels: z.ZodObject<{
-        required: z.ZodArray<z.ZodEnum<{
-            dflash: "dflash";
-            turboquant_q3: "turboquant_q3";
-            turboquant_q4: "turboquant_q4";
-            qjl: "qjl";
-            polarquant: "polarquant";
-            turbo3_tcq: "turbo3_tcq";
-        }>>;
-        optional: z.ZodArray<z.ZodEnum<{
-            dflash: "dflash";
-            turboquant_q3: "turboquant_q3";
-            turboquant_q4: "turboquant_q4";
-            qjl: "qjl";
-            polarquant: "polarquant";
-            turbo3_tcq: "turbo3_tcq";
-        }>>;
-        verifiedBackends: z.ZodObject<{
-            metal: z.ZodObject<{
-                status: z.ZodEnum<{
-                    pass: "pass";
-                    fail: "fail";
-                    skipped: "skipped";
-                }>;
-                atCommit: z.ZodString;
-                report: z.ZodString;
-            }, z.core.$strip>;
-            vulkan: z.ZodObject<{
-                status: z.ZodEnum<{
-                    pass: "pass";
-                    fail: "fail";
-                    skipped: "skipped";
-                }>;
-                atCommit: z.ZodString;
-                report: z.ZodString;
-            }, z.core.$strip>;
-            cuda: z.ZodObject<{
-                status: z.ZodEnum<{
-                    pass: "pass";
-                    fail: "fail";
-                    skipped: "skipped";
-                }>;
-                atCommit: z.ZodString;
-                report: z.ZodString;
-            }, z.core.$strip>;
-            cpu: z.ZodObject<{
-                status: z.ZodEnum<{
-                    pass: "pass";
-                    fail: "fail";
-                    skipped: "skipped";
-                }>;
-                atCommit: z.ZodString;
-                report: z.ZodString;
-            }, z.core.$strip>;
-        }, z.core.$strip>;
-    }, z.core.$strip>;
-    evals: z.ZodObject<{
-        textEval: z.ZodObject<{
-            score: z.ZodNumber;
-            passed: z.ZodBoolean;
-        }, z.core.$strip>;
-        voiceRtf: z.ZodObject<{
-            rtf: z.ZodNumber;
-            passed: z.ZodBoolean;
-        }, z.core.$strip>;
-        e2eLoopOk: z.ZodBoolean;
-        thirtyTurnOk: z.ZodBoolean;
-        asrWer: z.ZodOptional<z.ZodObject<{
-            wer: z.ZodNumber;
-            passed: z.ZodBoolean;
-        }, z.core.$strip>>;
-        embedMteb: z.ZodOptional<z.ZodObject<{
-            score: z.ZodNumber;
-            passed: z.ZodBoolean;
-        }, z.core.$strip>>;
-        vadLatencyMs: z.ZodOptional<z.ZodObject<{
-            median: z.ZodNumber;
-            passed: z.ZodBoolean;
-        }, z.core.$strip>>;
-        expressive: z.ZodOptional<z.ZodObject<{
-            tagFaithfulness: z.ZodNumber;
-            mosExpressive: z.ZodNumber;
-            tagLeakage: z.ZodNumber;
-            passed: z.ZodBoolean;
-        }, z.core.$strip>>;
-    }, z.core.$strip>;
-    ramBudgetMb: z.ZodObject<{
-        min: z.ZodNumber;
-        recommended: z.ZodNumber;
-    }, z.core.$strip>;
-    voice: z.ZodOptional<z.ZodObject<{
-        capabilities: z.ZodDefault<z.ZodArray<z.ZodEnum<{
-            tts: "tts";
-            "emotion-tags": "emotion-tags";
-            singing: "singing";
-        }>>>;
-    }, z.core.$strip>>;
-    defaultEligible: z.ZodBoolean;
-}, z.core.$strip>;
-//# sourceMappingURL=schema.d.ts.map

package/services/local-inference/manifest/schema.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../../../../src/services/local-inference/manifest/schema.ts"],"names":[],"mappings":"AAcA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,+BAA+B,EAAG,GAAY,CAAC;AAC5D,eAAO,MAAM,2BAA2B,EACtC,uDAAgE,CAAC;AAGnE,eAAO,MAAM,aAAa,+EAMhB,CAAC;AACX,MAAM,MAAM,UAAU,GAAG,CAAC,OAAO,aAAa,CAAC,CAAC,MAAM,CAAC,CAAC;AAQxD,eAAO,MAAM,eAAe,0FAOlB,CAAC;AACX,MAAM,MAAM,YAAY,GAAG,CAAC,OAAO,eAAe,CAAC,CAAC,MAAM,CAAC,CAAC;AAE5D,eAAO,MAAM,gBAAgB,6CAA8C,CAAC;AAC5E,MAAM,MAAM,aAAa,GAAG,CAAC,OAAO,gBAAgB,CAAC,CAAC,MAAM,CAAC,CAAC;AAa9D,eAAO,MAAM,wBAAwB,EAAE,QAAQ,CAC7C,MAAM,CAAC,UAAU,EAAE,aAAa,CAAC,YAAY,CAAC,CAAC,CAOhD,CAAC;AAIF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAC/C,MAAM,CAAC,UAAU,EAAE,aAAa,CAAC,aAAa,CAAC,CAAC,CAOjD,CAAC;AAeF,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAc9B,CAAC;AAEH,eAAO,MAAM,qBAAqB;;;;iBAOhC,CAAC;AAEH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAoB5B,CAAC;AAEH,eAAO,MAAM,sBAAsB;;;;;;;EAA0B,CAAC;AAC9D,eAAO,MAAM,uBAAuB;;;;;EAA2B,CAAC;AAChE,eAAO,MAAM,oBAAoB;;;;;;EAAwB,CAAC;AAE1D,eAAO,MAAM,iCAAiC;;;;;;;;iBAI5C,CAAC;AAEH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAS9B,CAAC;AAMH,eAAO,MAAM,0BAA0B,6CAI7B,CAAC;AACX,MAAM,MAAM,qBAAqB,GAAG,CAAC,OAAO,0BAA0B,CAAC,CAAC,MAAM,CAAC,CAAC;AAEhF,eAAO,MAAM,iBAAiB;;;;;;iBAE5B,CAAC;AAEH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA0C5B,CAAC;AAEH,eAAO,MAAM,qBAAqB;;;iBAO9B,CAAC;AAEL,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA4B7B,CAAC"}

package/services/local-inference/manifest/schema.js

@@ -1,227 +0,0 @@
-// Eliza-1 manifest schema (`eliza-1.manifest.json`).
-//
-// Source of truth: packages/inference/AGENTS.md §6 (manifest), §3 (mandatory
-// kernels), §2 (bundle/tier matrix). This module only defines the schema
-// and tier/kernel constants — runtime validation lives in `validator.ts`.
-//
-// Coupling notes:
-// - The kernel names here are *manifest-level* capabilities (what the bundle
-//   advertises), not the lower-level llama.cpp kernel handles in `../types.ts`
-//   (`turbo3` / `turbo4` / `turbo3_tcq` / `qjl_full` / `dflash`). The two
-//   layers map but are not the same enum.
-// - The schema URL `https://elizalabs.ai/schemas/eliza-1.manifest.v1.json` is
-//   exported as a JSON Schema sibling file in this directory.
-import { z } from "zod";
-export const ELIZA_1_MANIFEST_SCHEMA_VERSION = "1";
-export const ELIZA_1_MANIFEST_SCHEMA_URL = "https://elizalabs.ai/schemas/eliza-1.manifest.v1.json";
-// Tiers — see packages/inference/AGENTS.md §2 (Tier matrix).
-export const ELIZA_1_TIERS = [
-    "lite-0_6b",
-    "mobile-1_7b",
-    "desktop-9b",
-    "pro-27b",
-    "server-h200",
-];
-// Manifest-level kernel capability names. Per AGENTS.md §3:
-// `turboquant_q3`, `turboquant_q4`, `qjl`, `polarquant`, `dflash` are
-// the named optimizations the bundle declares. `turbo3_tcq` is optional
-// (long-context only). The C-level llama.cpp kernel handles in
-// `../types.ts` are an implementation detail of the runtime; the manifest
-// speaks in terms of the optimization, not the .metal/.comp file.
-export const ELIZA_1_KERNELS = [
-    "turboquant_q3",
-    "turboquant_q4",
-    "qjl",
-    "polarquant",
-    "dflash",
-    "turbo3_tcq",
-];
-export const ELIZA_1_BACKENDS = ["metal", "vulkan", "cuda", "cpu"];
-// Required-kernel set per tier. Mirrors AGENTS.md §3:
-// - All tiers require turboquant + qjl + polarquant + dflash.
-// - desktop / pro / server additionally have `turbo3_tcq` listed as required
-//   for the longest-context variant; we keep `turbo3_tcq` in the *optional*
-//   set so a bundle without the long-context variant can still publish, and
-//   require it dynamically when the bundle declares a >64k text file (the
-//   validator enforces that — see `validator.ts`).
-//
-// The `q3` vs `q4` choice is tier-driven: `lite` ships Q3, `mobile` ships
-// Q3 or Q4, the rest ship Q4. The validator accepts either turboquant
-// variant on `mobile`; other tiers must match exactly.
-export const REQUIRED_KERNELS_BY_TIER = {
-    "lite-0_6b": ["turboquant_q3", "qjl", "polarquant", "dflash"],
-    "mobile-1_7b": ["turboquant_q4", "qjl", "polarquant", "dflash"],
-    "desktop-9b": ["turboquant_q4", "qjl", "polarquant", "dflash"],
-    "pro-27b": ["turboquant_q4", "qjl", "polarquant", "dflash"],
-    "server-h200": ["turboquant_q4", "qjl", "polarquant", "dflash"],
-};
-// Backends each tier is expected to support on shipped hardware. A tier
-// that ships only on Apple silicon (mobile, lite) does not need cuda.
-export const SUPPORTED_BACKENDS_BY_TIER = {
-    "lite-0_6b": ["metal", "vulkan", "cpu"],
-    "mobile-1_7b": ["metal", "vulkan", "cpu"],
-    "desktop-9b": ["metal", "vulkan", "cuda", "cpu"],
-    "pro-27b": ["metal", "vulkan", "cuda", "cpu"],
-    "server-h200": ["cuda", "vulkan", "cpu"],
-};
-// ---------------------------------------------------------------------------
-// Zod definitions
-// ---------------------------------------------------------------------------
-const sha256 = z
-    .string()
-    .regex(/^[a-f0-9]{64}$/, "sha256 must be 64 lowercase hex chars");
-const lineageEntry = z.object({
-    base: z.string().min(1),
-    license: z.string().min(1),
-});
-export const Eliza1LineageSchema = z.object({
-    text: lineageEntry,
-    voice: lineageEntry,
-    drafter: lineageEntry,
-    // Wave-6 (2026-05-10): manifest now records lineage for every shipped
-    // component so license/dataset provenance is auditable per component.
-    // All optional — a tier may omit ASR/embedding/vision/vad/wakeword by
-    // leaving the corresponding `files.*` slot empty AND the lineage
-    // entry undefined. The validator enforces lineage-vs-files consistency.
-    asr: lineageEntry.optional(),
-    embedding: lineageEntry.optional(),
-    vision: lineageEntry.optional(),
-    vad: lineageEntry.optional(),
-    wakeword: lineageEntry.optional(),
-});
-export const Eliza1FileEntrySchema = z.object({
-    path: z.string().min(1),
-    sha256,
-    // text files declare their context length so the runtime can pick the
-    // largest variant that fits the device's RAM budget. Other file kinds
-    // never have ctx.
-    ctx: z.number().int().positive().optional(),
-});
-export const Eliza1FilesSchema = z.object({
-    text: z.array(Eliza1FileEntrySchema).min(1),
-    voice: z.array(Eliza1FileEntrySchema).min(1),
-    asr: z.array(Eliza1FileEntrySchema),
-    vision: z.array(Eliza1FileEntrySchema),
-    dflash: z.array(Eliza1FileEntrySchema).min(1),
-    cache: z.array(Eliza1FileEntrySchema).min(1),
-    // Wave-6 (2026-05-10): the omni bundle ships a per-bundle dedicated
-    // embedding model (Qwen3-Embedding-0.6B-GGUF on non-lite tiers) and
-    // a Silero-VAD ONNX + an optional openWakeWord ONNX. All three are
-    // optional in the schema — the lite tier intentionally omits the
-    // dedicated embedding (pools from text backbone) and a tier may
-    // ship without wake-word support.
-    //
-    // Schema-level optionality: empty array = "this bundle does not
-    // ship this component"; the validator enforces tier-specific
-    // consistency rules (e.g. mobile-and-up MUST ship `embedding[]`).
-    embedding: z.array(Eliza1FileEntrySchema).optional(),
-    vad: z.array(Eliza1FileEntrySchema).optional(),
-    wakeword: z.array(Eliza1FileEntrySchema).optional(),
-});
-export const Eliza1KernelEnumSchema = z.enum(ELIZA_1_KERNELS);
-export const Eliza1BackendEnumSchema = z.enum(ELIZA_1_BACKENDS);
-export const Eliza1TierEnumSchema = z.enum(ELIZA_1_TIERS);
-export const Eliza1VerifiedBackendStatusSchema = z.object({
-    status: z.enum(["pass", "fail", "skipped"]),
-    atCommit: z.string().min(1),
-    report: z.string().min(1),
-});
-export const Eliza1KernelsSchema = z.object({
-    required: z.array(Eliza1KernelEnumSchema).min(1),
-    optional: z.array(Eliza1KernelEnumSchema),
-    verifiedBackends: z.object({
-        metal: Eliza1VerifiedBackendStatusSchema,
-        vulkan: Eliza1VerifiedBackendStatusSchema,
-        cuda: Eliza1VerifiedBackendStatusSchema,
-        cpu: Eliza1VerifiedBackendStatusSchema,
-    }),
-});
-// Wave-6: voice surface declares which expressive features the bundled
-// TTS supports. Today these are tag-driven inline in the input text;
-// presence of `singing` or `emotion-tags` here lets the runtime expose
-// the relevant API surface and lets the planner emit tags inline.
-export const ELIZA_1_VOICE_CAPABILITIES = [
-    "tts",
-    "emotion-tags",
-    "singing",
-];
-export const Eliza1VoiceSchema = z.object({
-    capabilities: z.array(z.enum(ELIZA_1_VOICE_CAPABILITIES)).default(["tts"]),
-});
-export const Eliza1EvalsSchema = z.object({
-    textEval: z.object({
-        score: z.number().min(0).max(1),
-        passed: z.boolean(),
-    }),
-    voiceRtf: z.object({
-        rtf: z.number().nonnegative(),
-        passed: z.boolean(),
-    }),
-    e2eLoopOk: z.boolean(),
-    thirtyTurnOk: z.boolean(),
-    // Wave-6 additions — all optional so a tier can publish without
-    // an ASR / embedding component declared. `expressive` covers the
-    // singing/emotion-tag eval gates from `eliza1_gates.yaml`. The
-    // validator refuses defaultEligible=true if any declared component's
-    // gate is missing OR fails.
-    asrWer: z
-        .object({
-        wer: z.number().nonnegative(),
-        passed: z.boolean(),
-    })
-        .optional(),
-    embedMteb: z
-        .object({
-        score: z.number().min(0).max(1),
-        passed: z.boolean(),
-    })
-        .optional(),
-    vadLatencyMs: z
-        .object({
-        median: z.number().nonnegative(),
-        passed: z.boolean(),
-    })
-        .optional(),
-    expressive: z
-        .object({
-        tagFaithfulness: z.number().min(0).max(1),
-        mosExpressive: z.number().nonnegative(),
-        tagLeakage: z.number().nonnegative(),
-        passed: z.boolean(),
-    })
-        .optional(),
-});
-export const Eliza1RamBudgetSchema = z
-    .object({
-    min: z.number().int().positive(),
-    recommended: z.number().int().positive(),
-})
-    .refine((r) => r.recommended >= r.min, {
-    message: "ramBudgetMb.recommended must be >= ramBudgetMb.min",
-});
-export const Eliza1ManifestSchema = z
-    .object({
-    $schema: z.literal(ELIZA_1_MANIFEST_SCHEMA_URL).optional(),
-    id: z.string().min(1),
-    tier: Eliza1TierEnumSchema,
-    version: z
-        .string()
-        .regex(/^\d+\.\d+\.\d+(?:-[A-Za-z0-9.-]+)?$/, "version must be semver (e.g. 1.0.0)"),
-    publishedAt: z.string().datetime(),
-    lineage: Eliza1LineageSchema,
-    files: Eliza1FilesSchema,
-    kernels: Eliza1KernelsSchema,
-    evals: Eliza1EvalsSchema,
-    ramBudgetMb: Eliza1RamBudgetSchema,
-    // Wave-6: optional. Default = `{ capabilities: ["tts"] }` (base TTS only,
-    // no emotion tags, no singing). Bundles that ship the omnivoice-singing
-    // weights advertise `["tts","emotion-tags","singing"]`.
-    voice: Eliza1VoiceSchema.optional(),
-    defaultEligible: z.boolean(),
-})
-    // The id MUST encode the tier so catalogs can derive tier from id without
-    // re-reading the manifest. AGENTS.md §6 sample: `id: "eliza-1-desktop-9b"`.
-    .refine((m) => m.id === `eliza-1-${m.tier}` || m.id.startsWith(`eliza-1-${m.tier}-`), {
-    message: "id must start with `eliza-1-<tier>`",
-    path: ["id"],
-});

package/services/local-inference/manifest/types.d.ts

@@ -1,23 +0,0 @@
-import type { z } from "zod";
-import type { Eliza1BackendEnumSchema, Eliza1EvalsSchema, Eliza1FileEntrySchema, Eliza1FilesSchema, Eliza1KernelEnumSchema, Eliza1KernelsSchema, Eliza1LineageSchema, Eliza1ManifestSchema, Eliza1RamBudgetSchema, Eliza1TierEnumSchema, Eliza1VerifiedBackendStatusSchema } from "./schema";
-export type Eliza1Tier = z.infer<typeof Eliza1TierEnumSchema>;
-export type Eliza1Kernel = z.infer<typeof Eliza1KernelEnumSchema>;
-export type Eliza1Backend = z.infer<typeof Eliza1BackendEnumSchema>;
-export type Eliza1FileEntry = z.infer<typeof Eliza1FileEntrySchema>;
-export type Eliza1Files = z.infer<typeof Eliza1FilesSchema>;
-export type Eliza1Lineage = z.infer<typeof Eliza1LineageSchema>;
-export type Eliza1Kernels = z.infer<typeof Eliza1KernelsSchema>;
-export type Eliza1Evals = z.infer<typeof Eliza1EvalsSchema>;
-export type Eliza1RamBudget = z.infer<typeof Eliza1RamBudgetSchema>;
-export type Eliza1VerifiedBackendStatus = z.infer<typeof Eliza1VerifiedBackendStatusSchema>;
-export type Eliza1Manifest = z.infer<typeof Eliza1ManifestSchema>;
-/**
- * Capability snapshot of a target device — whatever the runtime detected
- * (Metal on Mac, Vulkan on Linux/Android, CUDA on NVIDIA, CPU as floor).
- * `canSetAsDefault()` checks the manifest's verifiedBackends against this.
- */
-export interface Eliza1DeviceCaps {
-    availableBackends: ReadonlyArray<Eliza1Backend>;
-    ramMb: number;
-}
-//# sourceMappingURL=types.d.ts.map

package/services/local-inference/manifest/types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../../../src/services/local-inference/manifest/types.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAC7B,OAAO,KAAK,EACV,uBAAuB,EACvB,iBAAiB,EACjB,qBAAqB,EACrB,iBAAiB,EACjB,sBAAsB,EACtB,mBAAmB,EACnB,mBAAmB,EACnB,oBAAoB,EACpB,qBAAqB,EACrB,oBAAoB,EACpB,iCAAiC,EAClC,MAAM,UAAU,CAAC;AAElB,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAC9D,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAClE,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AACpE,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AACpE,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAC5D,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAChE,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAChE,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAC5D,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AACpE,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAC/C,OAAO,iCAAiC,CACzC,CAAC;AACF,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAElE;;;;GAIG;AACH,MAAM,WAAW,gBAAgB;IAC/B,iBAAiB,EAAE,aAAa,CAAC,aAAa,CAAC,CAAC;IAChD,KAAK,EAAE,MAAM,CAAC;CACf"}

package/services/local-inference/manifest/types.js

@@ -1,5 +0,0 @@
-// TypeScript types derived from the Zod schema in `./schema.ts`.
-// Importing this module gives consumers a strongly-typed view of an Eliza-1
-// manifest without depending on Zod at runtime — useful for catalog code,
-// recommendation, and downloader interfaces that only read manifests.
-export {};