@qvac/sdk 0.17.1 → 0.18.1

package/dist/schemas/text-to-speech.js

@@ -77,6 +77,37 @@ export const TTS_PARLER_EMOTIONS = [
     'sad',
     'surprise'
 ];
+// Canonical cross-engine pace vocabulary (@qvac/tts-ggml `PACES`, unified in
+// QVAC-23154). `moderate` is the neutral pace: on CosyVoice3 it disengages the
+// pace conditioning channel entirely (plain zero-shot synthesis).
+export const TTS_PACES = ['slow', 'moderate', 'fast'];
+// CosyVoice3 supports a subset of the cross-engine emotion vocabulary and the
+// full canonical pace vocabulary.
+export const TTS_COSYVOICE3_EMOTIONS = ['anger', 'happy', 'neutral', 'sad'];
+// CosyVoice3 structured-instruct control vocabulary (@qvac/tts-ggml
+// `CosyvoiceInstruct`). Exactly one control renders per synthesis, resolved by
+// precedence dialect > volume > style.
+export const TTS_COSYVOICE3_INSTRUCT_DIALECTS = [
+    'cantonese',
+    'northeastern',
+    'gansu',
+    'guizhou',
+    'henan',
+    'hubei',
+    'hunan',
+    'jiangxi',
+    'minnan',
+    'ningxia',
+    'shanxi',
+    'shaanxi',
+    'shandong',
+    'shanghai',
+    'sichuan',
+    'tianjin',
+    'yunnan'
+];
+export const TTS_COSYVOICE3_INSTRUCT_VOLUMES = ['loud', 'soft'];
+export const TTS_COSYVOICE3_INSTRUCT_STYLES = ['peppa', 'robot'];
 // Supertonic languages not already present in the Chatterbox set, used to keep
 // TTS_LANGUAGES a true union across engines without duplicates.
 const TTS_SUPERTONIC_ONLY_LANGUAGES = [
@@ -103,6 +134,8 @@ export const TTS_LANGUAGES = [
 const ttsChatterboxLanguageSchema = z.enum(TTS_CHATTERBOX_LANGUAGES);
 const ttsSupertonicLanguageSchema = z.enum(TTS_SUPERTONIC_LANGUAGES);
 const ttsParlerEmotionSchema = z.enum(TTS_PARLER_EMOTIONS);
+const ttsCosyvoice3EmotionSchema = z.enum(TTS_COSYVOICE3_EMOTIONS);
+const ttsPaceSchema = z.enum(TTS_PACES);
 const ttsIntegerSchema = z.number().int();
 const ttsNonNegativeIntegerSchema = ttsIntegerSchema.nonnegative();
 const ttsPositiveIntegerSchema = ttsIntegerSchema.positive();
@@ -120,7 +153,9 @@ const ttsParlerDescriptionFieldsShape = {
     voice: z.string().min(1).optional(),
     emotion: ttsParlerEmotionSchema.optional(),
     pitch: z.string().min(1).optional(),
-    pace: z.string().min(1).optional(),
+    // Canonical cross-engine vocabulary since @qvac/tts-ggml 0.7 (QVAC-23154);
+    // free-form pace strings are rejected natively.
+    pace: ttsPaceSchema.optional(),
     expressivity: z.string().min(1).optional(),
     noise: z.string().min(1).optional(),
     reverb: z.string().min(1).optional(),
@@ -211,10 +246,102 @@ export const ttsParlerRuntimeConfigSchema = z
     normalizeNumbers: z.boolean().optional()
 })
     .superRefine(refineParlerRuntimeConfig);
+// CosyVoice3 structured instruct: a raw string passes through to the engine as
+// the exact instruction text (advanced escape hatch); the object form renders
+// exactly one trained control by precedence dialect > volume > style.
+// The string branch trims first: the addon trims too, so a whitespace-only
+// instruction would otherwise silently degrade to zero-shot synthesis.
+const ttsCosyvoice3InstructSchema = z.union([
+    z.string().trim().min(1),
+    z
+        .object({
+        dialect: z.enum(TTS_COSYVOICE3_INSTRUCT_DIALECTS).optional(),
+        volume: z.enum(TTS_COSYVOICE3_INSTRUCT_VOLUMES).optional(),
+        style: z.enum(TTS_COSYVOICE3_INSTRUCT_STYLES).optional()
+    })
+        .strict()
+        .refine((value) => value.dialect !== undefined || value.volume !== undefined || value.style !== undefined, { message: 'instruct requires at least one of dialect, volume, or style.' })
+]);
+// CosyVoice3 is trained on one instruction per synthesis: at most one of
+// `emotion`, a non-moderate `pace`, or `instruct` may be engaged at once
+// (`pace: 'moderate'` disengages the pace channel).
+function refineCosyvoice3ConditioningControls(config, ctx) {
+    const engaged = [];
+    if (config.emotion !== undefined)
+        engaged.push('emotion');
+    if (config.pace !== undefined && config.pace !== 'moderate')
+        engaged.push('pace');
+    if (config.instruct !== undefined)
+        engaged.push('instruct');
+    if (engaged.length > 1) {
+        ctx.addIssue({
+            code: 'custom',
+            path: [engaged[1]],
+            message: `CosyVoice3 accepts one conditioning control per synthesis; got ${engaged.join(', ')}. ` +
+                'Set exactly one (pace "moderate" disengages the pace channel).'
+        });
+    }
+}
+function refineCosyvoice3NativeStreamingRate(config, ctx) {
+    const nativeStreamingEnabled = (config.streamChunkTokens ?? 0) > 0;
+    if (nativeStreamingEnabled &&
+        config.outputSampleRate !== undefined &&
+        config.outputSampleRate !== 24000) {
+        ctx.addIssue({
+            code: 'custom',
+            path: ['outputSampleRate'],
+            message: 'CosyVoice3 native streaming emits at 24000 Hz; omit outputSampleRate, use 24000, ' +
+                'enable the LavaSR enhancer (which resamples seam-free), or disable native streaming.'
+        });
+    }
+}
+function refineCosyvoice3RuntimeConfig(config, ctx) {
+    refineCosyvoice3ConditioningControls(config, ctx);
+    refineCosyvoice3NativeStreamingRate(config, ctx);
+}
+const ttsCosyvoice3RuntimeConfigShape = {
+    ttsEngine: z.literal('cosyvoice3'),
+    emotion: ttsCosyvoice3EmotionSchema.optional(),
+    pace: ttsPaceSchema.optional(),
+    instruct: ttsCosyvoice3InstructSchema.optional(),
+    useGPU: z.boolean().optional(),
+    outputSampleRate: ttsOutputSampleRateSchema.optional(),
+    streamChunkTokens: ttsNonNegativeInt32Schema.optional(),
+    streamFirstChunkTokens: ttsNonNegativeInt32Schema.optional(),
+    threads: ttsPositiveInt32Schema.optional(),
+    nGpuLayers: ttsInt32Schema.optional(),
+    seed: ttsInt32Schema.optional()
+};
+export const ttsCosyvoice3RuntimeConfigSchema = z
+    .object(ttsCosyvoice3RuntimeConfigShape)
+    .superRefine(refineCosyvoice3RuntimeConfig);
+const ttsAudio8RuntimeConfigShape = {
+    ttsEngine: z.literal('audio8'),
+    // Transcript of the load-time reference recording (zero-shot voice cloning).
+    // Paired with `referenceAudioSrc` on the load config; kept on the runtime
+    // config because it survives artifact resolution as plain data.
+    // Trimmed for the same reason as the CosyVoice3 instruct string: a
+    // whitespace-only transcript would reach the engine as a non-empty value.
+    referenceText: z.string().trim().min(1).optional(),
+    greedy: z.boolean().optional(),
+    temperature: z.number().nonnegative().optional(),
+    topK: ttsNonNegativeInt32Schema.optional(),
+    topP: z.number().positive().max(1).optional(),
+    // Codec frames on Audio8's ~46 ms grid (~21.5 frames/s); 0 = engine default.
+    maxFrames: ttsNonNegativeInt32Schema.optional(),
+    useGPU: z.boolean().optional(),
+    outputSampleRate: ttsOutputSampleRateSchema.optional(),
+    threads: ttsPositiveInt32Schema.optional(),
+    nGpuLayers: ttsInt32Schema.optional(),
+    seed: ttsInt32Schema.optional()
+};
+export const ttsAudio8RuntimeConfigSchema = z.object(ttsAudio8RuntimeConfigShape);
 export const ttsRuntimeConfigSchema = z.discriminatedUnion('ttsEngine', [
     ttsChatterboxRuntimeConfigSchema,
     ttsSupertonicRuntimeConfigSchema,
-    ttsParlerRuntimeConfigSchema
+    ttsParlerRuntimeConfigSchema,
+    ttsCosyvoice3RuntimeConfigSchema,
+    ttsAudio8RuntimeConfigSchema
 ]);
 // Optional LavaSR post-processing model sources, shared across engines. Supply
 // the enhancer GGUF to bandwidth-extend the output to 48 kHz, and/or the
@@ -237,6 +364,65 @@ export const ttsSupertonicLoadConfigSchema = ttsSupertonicRuntimeConfigSchema.ex
     ...ttsLavasrLoadFieldsShape
 });
 export const ttsParlerLoadConfigSchema = ttsParlerRuntimeConfigSchema;
+function refineCosyvoice3LoadConfig(config, ctx) {
+    refineCosyvoice3ConditioningControls(config, ctx);
+    // With the LavaSR enhancer active the addon resamples seam-free, so the
+    // 24 kHz native-streaming restriction only applies without it.
+    if (config.lavasrEnhancerModelSrc === undefined) {
+        refineCosyvoice3NativeStreamingRate(config, ctx);
+    }
+    if (config.lavasrDenoiserModelSrc !== undefined && (config.streamChunkTokens ?? 0) > 0) {
+        ctx.addIssue({
+            code: 'custom',
+            path: ['lavasrDenoiserModelSrc'],
+            message: 'The LavaSR denoiser is batch-only; disable native streaming (streamChunkTokens) to use it.'
+        });
+    }
+}
+// CosyVoice3 loads from a model *directory* (LLM/flow/HiFT GGUFs plus
+// voice.gguf, vocab.json and merges.txt). The primary `modelSrc` is the LLM
+// GGUF, whose registry companion set co-locates the remaining files, so the
+// load config only adds the optional LavaSR post-processing sources.
+export const ttsCosyvoice3LoadConfigSchema = z
+    .object({
+    ...ttsCosyvoice3RuntimeConfigShape,
+    ...ttsLavasrLoadFieldsShape
+})
+    .superRefine(refineCosyvoice3LoadConfig);
+function refineAudio8LoadConfig(config, ctx) {
+    if (config.referenceAudioSrc !== undefined && config.referenceText === undefined) {
+        ctx.addIssue({
+            code: 'custom',
+            path: ['referenceText'],
+            message: 'referenceText (the transcript of the reference recording) is required with referenceAudioSrc.'
+        });
+    }
+    if (config.referenceText !== undefined && config.referenceAudioSrc === undefined) {
+        ctx.addIssue({
+            code: 'custom',
+            path: ['referenceAudioSrc'],
+            message: 'referenceAudioSrc is required when referenceText is set.'
+        });
+    }
+    if (config.referenceAudioSrc !== undefined && config.audio8CodecEncoderModelSrc === undefined) {
+        ctx.addIssue({
+            code: 'custom',
+            path: ['audio8CodecEncoderModelSrc'],
+            message: 'Voice cloning requires the Audio8 codec encoder GGUF (audio8CodecEncoderModelSrc).'
+        });
+    }
+}
+// Audio8 loads from explicit per-component GGUFs: the primary `modelSrc` is
+// the DualAR LM, the codec decoder is required, and the codec encoder is only
+// needed for zero-shot voice cloning (reference audio + transcript).
+export const ttsAudio8LoadConfigSchema = z
+    .object({
+    ...ttsAudio8RuntimeConfigShape,
+    audio8CodecDecoderModelSrc: modelSrcInputSchema,
+    audio8CodecEncoderModelSrc: modelSrcInputSchema.optional(),
+    referenceAudioSrc: modelSrcInputSchema.optional()
+})
+    .superRefine(refineAudio8LoadConfig);
 function refineChatterboxTokenizerAssets(data, ctx) {
     if (data.ttsEngine !== 'chatterbox')
         return;
@@ -259,7 +445,9 @@ export const ttsLoadConfigSchema = z
     .discriminatedUnion('ttsEngine', [
     ttsChatterboxLoadConfigSchema,
     ttsSupertonicLoadConfigSchema,
-    ttsParlerLoadConfigSchema
+    ttsParlerLoadConfigSchema,
+    ttsCosyvoice3LoadConfigSchema,
+    ttsAudio8LoadConfigSchema
 ])
     .superRefine(refineChatterboxTokenizerAssets);
 // === Legacy ONNX modelConfig fields (deprecated) ===
@@ -296,7 +484,9 @@ export const ttsConfigSchema = z
     .discriminatedUnion('ttsEngine', [
     ttsChatterboxLoadConfigSchema.extend(legacyTtsOnnxFieldsShape).strict(),
     ttsSupertonicLoadConfigSchema.extend(legacyTtsOnnxFieldsShape).strict(),
-    ttsParlerLoadConfigSchema.strict()
+    ttsParlerLoadConfigSchema.strict(),
+    ttsCosyvoice3LoadConfigSchema.strict(),
+    ttsAudio8LoadConfigSchema.strict()
 ])
     .superRefine(refineChatterboxTokenizerAssets);
 const ttsClientParamsShape = {

package/dist/schemas/tools.d.ts

@@ -1,20 +1,4 @@
 import { z } from 'zod';
-/**
- * `static` (default) — tools are prepended once after the system message and
- * shared across the chat session.
- * `dynamic` — tools are anchored after the last user message and trimmed
- * from the kv-cache once the tool-call chain resolves, so each user prompt
- * can carry its own tool set without poisoning the cache.
- *
- * Implementation detail: maps to the addon's `tools_compact` boolean. The
- * SDK uses the higher-level `static`/`dynamic` naming so the addon-side
- * mapping can change without breaking the public API.
- */
-export declare const TOOLS_MODE: {
-    readonly static: "static";
-    readonly dynamic: "dynamic";
-};
-export type ToolsMode = (typeof TOOLS_MODE)[keyof typeof TOOLS_MODE];
 export declare const toolSchema: z.ZodObject<{
     type: z.ZodLiteral<"function">;
     name: z.ZodString;

package/dist/schemas/tools.js

@@ -1,19 +1,4 @@
 import { z } from 'zod';
-/**
- * `static` (default) — tools are prepended once after the system message and
- * shared across the chat session.
- * `dynamic` — tools are anchored after the last user message and trimmed
- * from the kv-cache once the tool-call chain resolves, so each user prompt
- * can carry its own tool set without poisoning the cache.
- *
- * Implementation detail: maps to the addon's `tools_compact` boolean. The
- * SDK uses the higher-level `static`/`dynamic` naming so the addon-side
- * mapping can change without breaking the public API.
- */
-export const TOOLS_MODE = {
-    static: 'static',
-    dynamic: 'dynamic'
-};
 const jsonSchemaEnumValueSchema = z.union([z.string(), z.number(), z.boolean(), z.null()]);
 export const toolSchema = z.object({
     type: z.literal('function'),

package/dist/schemas/transcription-config.d.ts

@@ -120,6 +120,7 @@ export declare const parakeetRuntimeConfigSchema: z.ZodObject<{
     streamingEnergyVad: z.ZodOptional<z.ZodBoolean>;
     streamingLeftContextMs: z.ZodOptional<z.ZodNumber>;
     streamingRightLookaheadMs: z.ZodOptional<z.ZodNumber>;
+    language: z.ZodOptional<z.ZodString>;
     streamingSpkCacheEnable: z.ZodOptional<z.ZodBoolean>;
     streamingSpkCacheLen: z.ZodOptional<z.ZodNumber>;
     streamingFifoLen: z.ZodOptional<z.ZodNumber>;
@@ -144,6 +145,7 @@ export declare const parakeetConfigSchema: z.ZodObject<{
     streamingEnergyVad: z.ZodOptional<z.ZodBoolean>;
     streamingLeftContextMs: z.ZodOptional<z.ZodNumber>;
     streamingRightLookaheadMs: z.ZodOptional<z.ZodNumber>;
+    language: z.ZodOptional<z.ZodString>;
     streamingSpkCacheEnable: z.ZodOptional<z.ZodBoolean>;
     streamingSpkCacheLen: z.ZodOptional<z.ZodNumber>;
     streamingFifoLen: z.ZodOptional<z.ZodNumber>;

package/dist/schemas/transcription-config.js

@@ -104,6 +104,12 @@ export const parakeetRuntimeConfigSchema = z.object({
     streamingEnergyVad: z.boolean().optional(),
     streamingLeftContextMs: z.number().int().nonnegative().optional(),
     streamingRightLookaheadMs: z.number().int().nonnegative().optional(),
+    /**
+     * Multilingual CTC language id (e.g. `"hi"`, `"ta"`). Required for Indic
+     * Conformer GGUFs that advertise `parakeet.ctc.lang_*` ranges; ignored on
+     * monolingual CTC such as English `parakeet-ctc-0.6b`.
+     */
+    language: z.string().optional(),
     // === AOSC (Audio-Online Speaker Cache; v2.1+ Sortformer only) =========
     // Auto-enabled when the loaded GGUF carries
     // `parakeet.model_variant == "sortformer-streaming-v2.1-aosc"`. Ignored
@@ -117,10 +123,10 @@ export const parakeetRuntimeConfigSchema = z.object({
     backendsDir: z.string().optional(),
     openclCacheDir: z.string().optional()
 });
-// Parakeet's load-time config currently has no fields beyond the
-// runtime knobs (single GGUF model is supplied via the top-level
-// `modelSrc` of `loadModel`). The alias is retained so consumers can
-// keep importing `ParakeetConfig` / `parakeetConfigSchema`.
+// Parakeet's load-time config is the runtime knobs (single GGUF model is
+// supplied via the top-level `modelSrc` of `loadModel`). The alias is
+// retained so consumers can keep importing `ParakeetConfig` /
+// `parakeetConfigSchema`.
 export const parakeetConfigSchema = parakeetRuntimeConfigSchema;
 // === Parakeet legacy ONNX modelConfig fields (deprecated) ===
 //

package/dist/schemas/transcription.d.ts

@@ -225,12 +225,14 @@ export type TranscribeStreamClientParams = {
     parakeetStreamingConfig?: ParakeetStreamingRunConfig;
 };
 export interface TranscribeStreamSession {
+    stats: Promise<TranscribeStats | undefined>;
     write(audioChunk: Uint8Array): void;
     end(): void;
     destroy(): void;
     [Symbol.asyncIterator](): AsyncIterator<string>;
 }
 export interface TranscribeStreamMetadataSession {
+    stats: Promise<TranscribeStats | undefined>;
     write(audioChunk: Uint8Array): void;
     end(): void;
     destroy(): void;
@@ -252,6 +254,7 @@ export type TranscribeStreamEvent = {
     type: 'endOfTurn';
 } & EndOfTurnEvent);
 export interface TranscribeStreamConversationSession {
+    stats: Promise<TranscribeStats | undefined>;
     write(audioChunk: Uint8Array): void;
     end(): void;
     destroy(): void;

package/dist/schemas/vla.d.ts

@@ -1,10 +1,56 @@
 import { z } from 'zod';
+/**
+ * How a GR00T embodiment is named when selecting one: a tag string, its
+ * numeric `cat_id` (0..31), or an object carrying either plus an optional
+ * camera-count override. Mirrors the addon's `VlaEmbodimentSelector`.
+ *
+ * On the load path (`config.embodiment`) an object naming neither `tag` nor
+ * `catId` is allowed — the GGUF's default embodiment is used, with only the
+ * `numCameras` override applied.
+ */
+export declare const vlaEmbodimentSelectorSchema: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodObject<{
+    tag: z.ZodOptional<z.ZodString>;
+    catId: z.ZodOptional<z.ZodNumber>;
+    numCameras: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>]>;
+export type VlaEmbodimentSelector = z.input<typeof vlaEmbodimentSelectorSchema>;
+/**
+ * The selector shape `vlaSetEmbodiment` accepts: a switch must name an
+ * embodiment, so the neither-tag-nor-catId object form is rejected here
+ * (matching the addon's `setEmbodiment` validation).
+ */
+export declare const vlaEmbodimentSelectionSchema: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodObject<{
+    tag: z.ZodOptional<z.ZodString>;
+    catId: z.ZodOptional<z.ZodNumber>;
+    numCameras: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>]>;
+/**
+ * The static type matching `vlaEmbodimentSelectionSchema`. Hand-written
+ * because zod refinements don't narrow the inferred type — `z.input` of the
+ * schema would still allow the load-path-only `{ numCameras }` / `{}`
+ * spellings that the switch schema rejects at runtime. The `never` fields
+ * encode "exactly one of tag / catId" structurally.
+ */
+export type VlaEmbodimentSelection = string | number | {
+    tag: string;
+    catId?: never;
+    numCameras?: number;
+} | {
+    catId: number;
+    tag?: never;
+    numCameras?: number;
+};
 export declare const vlaConfigSchema: z.ZodObject<{
     backend: z.ZodOptional<z.ZodEnum<{
         cpu: "cpu";
         auto: "auto";
     }>>;
     verbosity: z.ZodOptional<z.ZodNumber>;
+    embodiment: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodObject<{
+        tag: z.ZodOptional<z.ZodString>;
+        catId: z.ZodOptional<z.ZodNumber>;
+        numCameras: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>]>>;
 }, z.core.$strip>;
 export type VlaConfig = z.input<typeof vlaConfigSchema>;
 export declare const vlaHparamsSchema: z.ZodObject<{
@@ -24,6 +70,8 @@ export declare const vlaHparamsSchema: z.ZodObject<{
         patches: "patches";
     }>>;
     imagePatchElems: z.ZodOptional<z.ZodNumber>;
+    selectedEmbodimentTag: z.ZodOptional<z.ZodString>;
+    selectedEmbodimentCatId: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
 export type VlaHparams = z.infer<typeof vlaHparamsSchema>;
 export declare const vlaStatsSchema: z.ZodObject<{
@@ -88,10 +136,45 @@ export declare const vlaHparamsResponseSchema: z.ZodObject<{
             patches: "patches";
         }>>;
         imagePatchElems: z.ZodOptional<z.ZodNumber>;
+        selectedEmbodimentTag: z.ZodOptional<z.ZodString>;
+        selectedEmbodimentCatId: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>;
     backendName: z.ZodNullable<z.ZodString>;
 }, z.core.$strip>;
 export type VlaHparamsResponse = z.infer<typeof vlaHparamsResponseSchema>;
+export declare const vlaSetEmbodimentRequestSchema: z.ZodObject<{
+    type: z.ZodLiteral<"vlaSetEmbodiment">;
+    modelId: z.ZodString;
+    embodiment: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodObject<{
+        tag: z.ZodOptional<z.ZodString>;
+        catId: z.ZodOptional<z.ZodNumber>;
+        numCameras: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>]>;
+}, z.core.$strip>;
+export type VlaSetEmbodimentRequest = z.input<typeof vlaSetEmbodimentRequestSchema>;
+export declare const vlaSetEmbodimentResponseSchema: z.ZodObject<{
+    hparams: z.ZodObject<{
+        chunkSize: z.ZodNumber;
+        actionDim: z.ZodNumber;
+        maxActionDim: z.ZodNumber;
+        maxStateDim: z.ZodNumber;
+        tokenizerMaxLength: z.ZodNumber;
+        visionImageSize: z.ZodNumber;
+        numCameras: z.ZodOptional<z.ZodNumber>;
+        stateInputMode: z.ZodOptional<z.ZodEnum<{
+            discrete: "discrete";
+            continuous: "continuous";
+        }>>;
+        imageInputMode: z.ZodOptional<z.ZodEnum<{
+            pixels: "pixels";
+            patches: "patches";
+        }>>;
+        imagePatchElems: z.ZodOptional<z.ZodNumber>;
+        selectedEmbodimentTag: z.ZodOptional<z.ZodString>;
+        selectedEmbodimentCatId: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type VlaSetEmbodimentResponse = z.infer<typeof vlaSetEmbodimentResponseSchema>;
 export interface VlaClientRunParams {
     modelId: string;
     images: Float32Array[];

package/dist/schemas/vla.js

@@ -1,6 +1,73 @@
 import { z } from 'zod';
 const BASE64_PATTERN = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/;
 // ============================================
+// Embodiment selection (GR00T only)
+// ============================================
+// Bounds mirrored from @qvac/vla-ggml: a cat_id indexes GR00T's
+// CategorySpecificLinear bank whose category dim the architecture fixes at 32,
+// and the native resolver caps camera counts at 64.
+const MAX_EMBODIMENT_CAT_ID = 31;
+const MAX_NUM_CAMERAS = 64;
+// Sanity bound, not an addon contract — the addon only requires non-empty.
+// Real tags are short snake_case identifiers (longest known: 37 chars); the
+// cap stops a garbage or hostile string from travelling into the native
+// resolver while leaving ample headroom for legitimate tags.
+const MAX_EMBODIMENT_TAG_LENGTH = 256;
+const embodimentTagSchema = z
+    .string()
+    .min(1)
+    .max(MAX_EMBODIMENT_TAG_LENGTH)
+    .describe("Embodiment tag string as stored in the GGUF (e.g. 'libero_sim').");
+const embodimentCatIdSchema = z
+    .number()
+    .int()
+    .min(0)
+    .max(MAX_EMBODIMENT_CAT_ID)
+    .describe("The embodiment's numeric `cat_id` (0..31).");
+const embodimentObjectSchema = z
+    .object({
+    tag: embodimentTagSchema.optional(),
+    catId: embodimentCatIdSchema.optional(),
+    numCameras: z
+        .number()
+        .int()
+        .min(1)
+        .max(MAX_NUM_CAMERAS)
+        .optional()
+        .describe('Overrides the camera count stored in the GGUF for the selected ' +
+        'embodiment. Required to select an embodiment whose count was ' +
+        'unknown at conversion time.')
+})
+    .refine((value) => value.tag === undefined || value.catId === undefined, {
+    message: 'embodiment accepts either tag or catId, not both'
+});
+/**
+ * How a GR00T embodiment is named when selecting one: a tag string, its
+ * numeric `cat_id` (0..31), or an object carrying either plus an optional
+ * camera-count override. Mirrors the addon's `VlaEmbodimentSelector`.
+ *
+ * On the load path (`config.embodiment`) an object naming neither `tag` nor
+ * `catId` is allowed — the GGUF's default embodiment is used, with only the
+ * `numCameras` override applied.
+ */
+export const vlaEmbodimentSelectorSchema = z.union([
+    embodimentTagSchema,
+    embodimentCatIdSchema,
+    embodimentObjectSchema
+]);
+/**
+ * The selector shape `vlaSetEmbodiment` accepts: a switch must name an
+ * embodiment, so the neither-tag-nor-catId object form is rejected here
+ * (matching the addon's `setEmbodiment` validation).
+ */
+export const vlaEmbodimentSelectionSchema = z.union([
+    embodimentTagSchema,
+    embodimentCatIdSchema,
+    embodimentObjectSchema.refine((value) => value.tag !== undefined || value.catId !== undefined, {
+        message: 'embodiment must name a tag or a catId'
+    })
+]);
+// ============================================
 // Load-time config
 // ============================================
 export const vlaConfigSchema = z.object({
@@ -14,7 +81,13 @@ export const vlaConfigSchema = z.object({
         .number()
         .int()
         .optional()
-        .describe('Native log verbosity forwarded to the addon (0=ERROR, 1=WARN, 2=INFO, 3=DEBUG).')
+        .describe('Native log verbosity forwarded to the addon (0=ERROR, 1=WARN, 2=INFO, 3=DEBUG).'),
+    embodiment: vlaEmbodimentSelectorSchema
+        .optional()
+        .describe('GR00T only: which embodiment of a multi-embodiment GGUF to activate at ' +
+        'load — a tag string, a numeric `cat_id` (0..31), or `{ tag | catId, ' +
+        "numCameras }`. Omitted = the GGUF's default embodiment. Rejected by " +
+        'the addon for non-GR00T models.')
 });
 // ============================================
 // Hparams (returned by the addon after load)
@@ -57,7 +130,23 @@ export const vlaHparamsSchema = z.object({
         .optional()
         .describe("For patch-input models (`imageInputMode === 'patches'`), the exact " +
         'per-camera patch buffer length each `images` entry must have. Absent ' +
-        'for pixel-input models.')
+        'for pixel-input models.'),
+    selectedEmbodimentTag: z
+        .string()
+        .optional()
+        .describe('GR00T only: the embodiment tag resolved at load / after ' +
+        '`vlaSetEmbodiment`. Absent for SmolVLA / π₀.₅. Present is not the ' +
+        'same as switchable — a single-embodiment GGUF reports its baked tag ' +
+        'and still rejects `vlaSetEmbodiment`.'),
+    selectedEmbodimentCatId: z
+        .number()
+        .int()
+        .min(0)
+        .max(MAX_EMBODIMENT_CAT_ID)
+        .optional()
+        .describe("The resolved embodiment's numeric `cat_id` — the value to pass back " +
+        'to select the same embodiment by id. Absent when no embodiment was ' +
+        'resolved (SmolVLA / π₀.₅).')
 });
 // ============================================
 // Stats
@@ -149,3 +238,17 @@ export const vlaHparamsResponseSchema = z.object({
     hparams: vlaHparamsSchema,
     backendName: z.string().nullable()
 });
+// ============================================
+// Set-embodiment request / response (plugin handler)
+// ============================================
+export const vlaSetEmbodimentRequestSchema = z.object({
+    type: z.literal('vlaSetEmbodiment'),
+    modelId: z.string(),
+    embodiment: vlaEmbodimentSelectionSchema.describe('The embodiment to switch the loaded GR00T model to — a tag string, a ' +
+        'numeric `cat_id` (0..31), or `{ tag | catId, numCameras }`. Must name ' +
+        'a tag or a catId.')
+});
+export const vlaSetEmbodimentResponseSchema = z.object({
+    hparams: vlaHparamsSchema.describe('The refreshed hparams after the switch — `numCameras`, `actionDim` and ' +
+        'the `selectedEmbodiment*` fields follow the newly active embodiment.')
+});

package/dist/scripts/link-workspace-inference.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=link-workspace-inference.d.ts.map

package/dist/scripts/link-workspace-inference.js

@@ -0,0 +1,31 @@
+// Overrides the SDK's @qvac/inference dependency with the in-monorepo sibling
+// for the "workspace" pod-check leg, so the SDK builds and tests against the
+// engine at the same commit.
+import { readFileSync, writeFileSync } from 'fs';
+import { join, resolve, dirname } from 'path';
+import { spawnSync } from 'child_process';
+import { fileURLToPath } from 'url';
+const sdkDir = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+const inferenceDir = resolve(sdkDir, '..', 'inference');
+function declaresInference() {
+    const pkg = JSON.parse(readFileSync(join(sdkDir, 'package.json'), 'utf8'));
+    return Boolean(pkg.dependencies?.['@qvac/inference']);
+}
+function run(command, args, cwd) {
+    const { status, error } = spawnSync(command, args, { cwd, stdio: 'inherit' });
+    if (error)
+        throw error;
+    if (status !== 0)
+        process.exit(status ?? 1);
+}
+if (!declaresInference()) {
+    console.log('[link-workspace-inference] @qvac/inference is not a dependency; skipping');
+    process.exit(0);
+}
+run('bun', ['install'], inferenceDir);
+run('bun', ['run', 'build'], inferenceDir);
+const manifestPath = join(sdkDir, 'package.json');
+const pkg = JSON.parse(readFileSync(manifestPath, 'utf8'));
+pkg.dependencies['@qvac/inference'] = 'file:../inference';
+writeFileSync(manifestPath, `${JSON.stringify(pkg, null, 2)}\n`);
+run('bun', ['install'], sdkDir);

package/dist/server/bare/ops/cancel.d.ts

@@ -5,7 +5,7 @@ import type { RequestKind } from '../../../server/bare/runtime/index.js';
  * optionally a `kind`). Maps onto `RequestRegistry.cancel({ modelId })`
  * — the registry walks active contexts and aborts each one's signal,
  * which each handler has wired to its own addon-level / async unwind
- * via the registry's `await using ctx = registry.begin(...)` block.
+ * via the registry's `await using ctx = await registry.begin(...)` block.
  *
  * Kept as a stable surface alongside the new `cancel({ requestId })`
  * path: the caller may not have a `requestId` to hand (model unload,

package/dist/server/bare/ops/cancel.js

@@ -9,7 +9,7 @@ const logger = getServerLogger();
  * optionally a `kind`). Maps onto `RequestRegistry.cancel({ modelId })`
  * — the registry walks active contexts and aborts each one's signal,
  * which each handler has wired to its own addon-level / async unwind
- * via the registry's `await using ctx = registry.begin(...)` block.
+ * via the registry's `await using ctx = await registry.begin(...)` block.
  *
  * Kept as a stable surface alongside the new `cancel({ requestId })`
  * path: the caller may not have a `requestId` to hand (model unload,