@qvac/sdk 0.16.0 → 0.17.0

package/dist/models/update-models/codegen.d.ts

@@ -1,3 +1,3 @@
-import type { ProcessedModel } from './types';
+import type { ProcessedModel } from './types.js';
 export declare function generateModelsFileContent(models: ProcessedModel[]): string;
 //# sourceMappingURL=codegen.d.ts.map

package/dist/models/update-models/companions.d.ts

@@ -1,4 +1,4 @@
-import type { ProcessedModel } from './types';
+import type { ProcessedModel } from './types.js';
 /**
  * Detects companion file relationships among processed models and
  * attaches `companionSet` metadata to each primary entry.

package/dist/models/update-models/history.d.ts

@@ -1,4 +1,4 @@
-import type { CurrentModel, ProcessedModel } from './types';
+import type { CurrentModel, ProcessedModel } from './types.js';
 export declare function loadCurrentModels(outputFile: string): CurrentModel[];
 export declare function compareModels(remoteModels: ProcessedModel[], currentModels: CurrentModel[]): {
     added: ProcessedModel[];

package/dist/models/update-models/history.js

@@ -13,13 +13,13 @@ export function loadCurrentModels(outputFile) {
         }
         const modelsArrayContent = modelsMatch[1];
         const currentModels = [];
-        const modelRegex = /\{[^}]+name:\s*"([^"]+)"[^}]+(?:registryPath|hyperbeeKey):\s*"([^"]+)"[^}]+\}/g;
+        const modelRegex = /\{[^}]+name:\s*(['"`])([^'"`]+)\1[^}]+(?:registryPath|hyperbeeKey):\s*(['"`])([^'"`]+)\3[^}]+\}/g;
         let match;
         while ((match = modelRegex.exec(modelsArrayContent)) !== null) {
-            if (match[1] && match[2]) {
+            if (match[2] && match[4]) {
                 currentModels.push({
-                    name: match[1],
-                    registryPath: match[2]
+                    name: match[2],
+                    registryPath: match[4]
                 });
             }
         }

package/dist/models/update-models/naming.d.ts

@@ -1,4 +1,4 @@
-import type { ExportNameInput } from './types';
+import type { ExportNameInput } from './types.js';
 export declare function cleanPart(p: string): string;
 export declare function generateExportName({ path: registryPath, engine, name: modelName, quantization, params, tags, usedNames }: ExportNameInput): string;
 //# sourceMappingURL=naming.d.ts.map

package/dist/models/update-models/naming.js

@@ -1,4 +1,4 @@
-import { getAddonFromEngine } from '../../schemas/engine-addon-map';
+import { getAddonFromEngine } from '../../schemas/engine-addon-map.js';
 import { detectShardedModel } from './shards.js';
 // Normalizes a name part to a valid JS export name fragment.
 // Strips ggml/gguf prefixes, shortens "instruct" to "inst",
@@ -104,10 +104,16 @@ function generateBaseName(input) {
             return generateParakeetName(input);
         case 'diffusion':
             return generateDiffusionName(input);
+        case 'audiogen':
+            return generateAudioGenName(input);
         default:
             return cleanPart(input.filename.replace(/\.\w+$/, ''));
     }
 }
+function generateAudioGenName({ filename }) {
+    const modelName = cleanPart(filename.replace(/\.\w+$/, ''));
+    return `AUDIOGEN_${modelName}`;
+}
 function generateVadSileroName({ filename }) {
     const versionMatch = filename.match(/v(\d+\.\d+\.\d+)/i);
     const version = versionMatch ? versionMatch[1] : '';

package/dist/models/update-models/processing.d.ts

@@ -1,5 +1,5 @@
 import type { QVACModelEntry } from '@qvac/registry-client';
-import type { ProcessedModel } from './types';
+import type { ProcessedModel } from './types.js';
 export declare function toHexString(value: Buffer | string | {
     data: number[];
 } | undefined): string;

package/dist/models/update-models/processing.js

@@ -1,4 +1,4 @@
-import { getAddonFromEngine, resolveCanonicalEngine } from '../../schemas/engine-addon-map';
+import { getAddonFromEngine, resolveCanonicalEngine } from '../../schemas/engine-addon-map.js';
 import { detectShardedModel } from './shards.js';
 export function toHexString(value) {
     if (!value)

package/dist/models/update-models/registry.d.ts

@@ -1,5 +1,5 @@
-import type { CollectOptions, ProcessedModel } from './types';
-export { processRegistryModel, extractModelName, toHexString } from './processing';
+import type { CollectOptions, ProcessedModel } from './types.js';
+export { processRegistryModel, extractModelName, toHexString } from './processing.js';
 export declare function collectModels(options?: CollectOptions): Promise<ProcessedModel[]>;
 export declare function deduplicateModels(models: ProcessedModel[], showDuplicates: boolean): ProcessedModel[];
 //# sourceMappingURL=registry.d.ts.map

package/dist/models/update-models/shards.d.ts

@@ -1,4 +1,4 @@
-import type { ProcessedModel, ShardDetection } from './types';
+import type { ProcessedModel, ShardDetection } from './types.js';
 export declare function detectShardedModel(filename: string): ShardDetection;
 export declare function groupShardedModels(models: ProcessedModel[]): ProcessedModel[];
 //# sourceMappingURL=shards.d.ts.map

package/dist/models/update-models/types.d.ts

@@ -1,4 +1,4 @@
-import type { ModelRegistryEntryAddon, ModelRegistryEngine } from '../../schemas/registry';
+import type { ModelRegistryEntryAddon, ModelRegistryEngine } from '../../schemas/registry.js';
 export interface ShardInfo {
     isSharded: true;
     baseFilename: string;

package/dist/pear/pre.js

@@ -36,6 +36,7 @@ const BUILTIN_PLUGINS = [
     '@qvac/sdk/tts-ggml/plugin',
     '@qvac/sdk/ggml-ocr/plugin',
     '@qvac/sdk/sdcpp-generation/plugin',
+    '@qvac/sdk/audiogen-ggml/plugin',
     '@qvac/sdk/ggml-vla/plugin',
     '@qvac/sdk/ggml-classification/plugin'
 ];
@@ -48,6 +49,7 @@ const BUILTIN_PLUGIN_EXPORTS = {
     'tts-ggml': 'ttsPlugin',
     'ggml-ocr': 'ocrPlugin',
     'sdcpp-generation': 'diffusionPlugin',
+    'audiogen-ggml': 'audioGenPlugin',
     'ggml-vla': 'vlaPlugin',
     'ggml-classification': 'classificationPlugin'
 };

package/dist/profiling/aggregator.d.ts

@@ -2,7 +2,7 @@
  * Accumulates profiling statistics and maintains a bounded buffer of recent events.
  * Uses a ring buffer for O(1) event insertion.
  */
-import type { ProfilingEvent, AggregatedStats } from './types';
+import type { ProfilingEvent, AggregatedStats } from './types.js';
 export declare function createAggregator(maxRecentEvents?: number): void;
 export declare function recordEvent(event: ProfilingEvent, storeInBuffer?: boolean): void;
 export declare function getAggregates(): Record<string, AggregatedStats>;

package/dist/profiling/backend-diagnostics.d.ts

@@ -0,0 +1,8 @@
+import { type InferenceBackendDiagnostics } from '../schemas/index.js';
+/**
+ * Attaches diagnostics to a unary addon result, a plugin model-factory result,
+ * or the terminal chunk of a streaming addon result. Earlier stream chunks are not inspected.
+ */
+export declare function attachBackendDiagnostics<T extends object>(target: T, diagnostics: InferenceBackendDiagnostics): T;
+export declare function forwardBackendDiagnostics<T extends object>(target: T, source: unknown): T;
+//# sourceMappingURL=backend-diagnostics.d.ts.map

package/dist/profiling/backend-diagnostics.js

@@ -0,0 +1,21 @@
+import { BACKEND_DIAGNOSTICS_KEY, inferenceBackendDiagnosticsSchema } from '../schemas/index.js';
+/**
+ * Attaches diagnostics to a unary addon result, a plugin model-factory result,
+ * or the terminal chunk of a streaming addon result. Earlier stream chunks are not inspected.
+ */
+export function attachBackendDiagnostics(target, diagnostics) {
+    const parsed = inferenceBackendDiagnosticsSchema.parse(diagnostics);
+    target[BACKEND_DIAGNOSTICS_KEY] =
+        parsed;
+    return target;
+}
+export function forwardBackendDiagnostics(target, source) {
+    if (!source || typeof source !== 'object')
+        return target;
+    const diagnostics = source[BACKEND_DIAGNOSTICS_KEY];
+    if (diagnostics !== undefined) {
+        ;
+        target[BACKEND_DIAGNOSTICS_KEY] = diagnostics;
+    }
+    return target;
+}

package/dist/profiling/controller.d.ts

@@ -6,12 +6,13 @@
  * 2. Runtime API (enable/disable)
  * 3. Disabled default
  */
-import type { ProfilerMode, PerCallProfiling } from '../schemas/index';
-import type { ProfilerRuntimeOptions, ProfilingEvent, AggregatedStats } from './types';
+import type { ProfilerMode, PerCallProfiling } from '../schemas/index.js';
+import type { ProfilerRuntimeOptions, ProfilingEvent, AggregatedStats } from './types.js';
 export interface ResolvedProfilerConfig {
     enabled: boolean;
     mode: ProfilerMode;
     includeServerBreakdown: boolean;
+    includeResourceGauges: boolean;
     operationFilters: string[];
     maxRecentEvents: number;
 }
@@ -22,6 +23,7 @@ export declare function isEnabled(): boolean;
 export declare function getEffectiveConfig(): ResolvedProfilerConfig;
 export declare function shouldProfile(operation: string, perCallOptions?: PerCallProfiling): boolean;
 export declare function shouldIncludeServerBreakdown(perCallOptions?: PerCallProfiling): boolean;
+export declare function shouldIncludeResourceGauges(perCallOptions?: PerCallProfiling): boolean;
 export declare function generateId(): string;
 export declare function record(event: ProfilingEvent): void;
 /** Returns unsubscribe function. */

package/dist/profiling/controller.js

@@ -13,6 +13,7 @@ const DEFAULT_CONFIG = {
     enabled: false,
     mode: 'summary',
     includeServerBreakdown: false,
+    includeResourceGauges: false,
     operationFilters: [],
     maxRecentEvents: 1000
 };
@@ -55,6 +56,7 @@ export function getEffectiveConfig() {
         enabled: isEnabled(),
         mode: state.runtimeOptions.mode ?? DEFAULT_CONFIG.mode,
         includeServerBreakdown: state.runtimeOptions.includeServerBreakdown ?? DEFAULT_CONFIG.includeServerBreakdown,
+        includeResourceGauges: state.runtimeOptions.includeResourceGauges ?? DEFAULT_CONFIG.includeResourceGauges,
         operationFilters: [
             ...(state.runtimeOptions.operationFilters ?? DEFAULT_CONFIG.operationFilters)
         ],
@@ -80,6 +82,12 @@ export function shouldIncludeServerBreakdown(perCallOptions) {
     }
     return getEffectiveConfig().includeServerBreakdown;
 }
+export function shouldIncludeResourceGauges(perCallOptions) {
+    if (perCallOptions?.includeResourceGauges !== undefined) {
+        return perCallOptions.includeResourceGauges;
+    }
+    return getEffectiveConfig().includeResourceGauges;
+}
 export function generateId() {
     return generateProfileId();
 }

package/dist/profiling/envelope.d.ts

@@ -1,9 +1,10 @@
 /**
  * Helpers to inject/extract __profiling metadata in RPC payloads.
  */
-import { type ProfilingRequestMeta, type ProfilingResponseMeta } from '../schemas/index';
-export declare function createProfilingMeta(profileId: string, includeServerBreakdown: boolean): ProfilingRequestMeta;
+import { type ProfilingRequestMeta, type ProfilingResponseMeta } from '../schemas/index.js';
+export declare function createProfilingMeta(profileId: string, includeServerBreakdown: boolean, includeResourceGauges: boolean): ProfilingRequestMeta;
 export declare function createProfilingDisabledMeta(): ProfilingRequestMeta;
+export declare function createDelegatedProfilingMeta(profileId: string, meta?: ProfilingRequestMeta): ProfilingRequestMeta;
 export declare function injectProfilingMetaIntoObject(obj: Record<string, unknown>, meta: ProfilingRequestMeta): Record<string, unknown>;
 export declare function extractProfilingMeta(payload: unknown): ProfilingResponseMeta | undefined;
 export declare function stripProfilingMeta<T extends object>(payload: T): T;

package/dist/profiling/envelope.js

@@ -2,16 +2,27 @@
  * Helpers to inject/extract __profiling metadata in RPC payloads.
  */
 import { PROFILING_KEY } from '../schemas/index.js';
-export function createProfilingMeta(profileId, includeServerBreakdown) {
+export function createProfilingMeta(profileId, includeServerBreakdown, includeResourceGauges) {
     return {
         enabled: true,
         id: profileId,
-        includeServer: includeServerBreakdown
+        includeServer: includeServerBreakdown,
+        includeResources: includeResourceGauges
     };
 }
 export function createProfilingDisabledMeta() {
     return { enabled: false };
 }
+export function createDelegatedProfilingMeta(profileId, meta) {
+    return {
+        enabled: true,
+        id: profileId,
+        includeServer: meta?.includeServer ?? false,
+        includeResources: meta?.includeResources ?? false,
+        resourceOrigin: 'provider',
+        ...(meta?.mode !== undefined && { mode: meta.mode })
+    };
+}
 export function injectProfilingMetaIntoObject(obj, meta) {
     return { ...obj, [PROFILING_KEY]: meta };
 }

package/dist/profiling/events.d.ts

@@ -1,5 +1,5 @@
-import type { ProfilingEventKind } from './types';
-import type { ServerBreakdown, DelegationBreakdown } from '../schemas/index';
+import type { ProfilingEventKind } from './types.js';
+import type { ServerBreakdown, DelegationBreakdown } from '../schemas/index.js';
 export interface BaseTimings {
     profileId: string;
     requestType: string;

package/dist/profiling/exporters.d.ts

@@ -1,7 +1,7 @@
 /**
  * JSON, table, and summary export utilities for profiling data.
  */
-import type { ProfilerExport } from './types';
+import type { ProfilerExport } from './types.js';
 export declare function exportJSON(options?: {
     includeRecentEvents?: boolean;
 }): ProfilerExport;

package/dist/profiling/index.d.ts

@@ -11,8 +11,8 @@
  * profiler.disable();
  * ```
  */
-import * as controller from './controller';
-import type { ProfilerRuntimeOptions, ProfilingEvent, ProfilerExport, AggregatedStats } from './types';
+import * as controller from './controller.js';
+import type { ProfilerRuntimeOptions, ProfilingEvent, ProfilerExport, AggregatedStats } from './types.js';
 export declare const profiler: {
     /**
      * Enables profiling and resets all previously aggregated data.
@@ -76,10 +76,11 @@ export declare const profiler: {
      */
     clear: () => void;
 };
-export type { ProfilerRuntimeOptions, ProfilingEvent, ProfilerExport, AggregatedStats, ProfilingEventKind } from './types';
-export type { ProfilerMode } from '../schemas/index';
-export { nowMs } from './clock';
-export { record, shouldProfile, shouldIncludeServerBreakdown, generateId, isEnabled, type ResolvedProfilerConfig } from './controller';
-export { createProfilingMeta, createProfilingDisabledMeta, injectProfilingMetaIntoObject, extractProfilingMeta, stripProfilingMeta } from './envelope';
-export { recordPhase, recordFailure, recordServerBreakdownPhases, recordDelegationBreakdownPhases, type BaseTimings, type BaseEvent } from './events';
+export type { ProfilerRuntimeOptions, ProfilingEvent, ProfilerExport, AggregatedStats, ProfilingEventKind } from './types.js';
+export type { ProfilerMode, ProfilerGPUResourceGauge, ProfilerResourceGauge } from '../schemas/index.js';
+export { nowMs } from './clock.js';
+export { attachBackendDiagnostics } from './backend-diagnostics.js';
+export { record, shouldProfile, shouldIncludeServerBreakdown, shouldIncludeResourceGauges, generateId, isEnabled, type ResolvedProfilerConfig } from './controller.js';
+export { createProfilingMeta, createDelegatedProfilingMeta, createProfilingDisabledMeta, injectProfilingMetaIntoObject, extractProfilingMeta, stripProfilingMeta } from './envelope.js';
+export { recordPhase, recordFailure, recordServerBreakdownPhases, recordDelegationBreakdownPhases, type BaseTimings, type BaseEvent } from './events.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/profiling/index.js

@@ -75,6 +75,7 @@ export const profiler = {
     clear: () => controller.clear()
 };
 export { nowMs } from './clock.js';
-export { record, shouldProfile, shouldIncludeServerBreakdown, generateId, isEnabled } from './controller.js';
-export { createProfilingMeta, createProfilingDisabledMeta, injectProfilingMetaIntoObject, extractProfilingMeta, stripProfilingMeta } from './envelope.js';
+export { attachBackendDiagnostics } from './backend-diagnostics.js';
+export { record, shouldProfile, shouldIncludeServerBreakdown, shouldIncludeResourceGauges, generateId, isEnabled } from './controller.js';
+export { createProfilingMeta, createDelegatedProfilingMeta, createProfilingDisabledMeta, injectProfilingMetaIntoObject, extractProfilingMeta, stripProfilingMeta } from './envelope.js';
 export { recordPhase, recordFailure, recordServerBreakdownPhases, recordDelegationBreakdownPhases } from './events.js';

package/dist/profiling/types.d.ts

@@ -1,3 +1,5 @@
+import type { ProfilerResourceGauge } from '../schemas/profiling.js';
+import type { InferenceBackendDiagnostics } from '../schemas/system-resources.js';
 export type ProfilingEventKind = 'rpc' | 'handler' | 'download' | 'load' | 'delegation';
 export interface ProfilingEvent {
     /** Timestamp when event was recorded (monotonic ms) */
@@ -12,12 +14,15 @@ export interface ProfilingEvent {
     bytes?: number;
     /** Numeric gauges (e.g., throughput, token counters) */
     gauges?: Record<string, number>;
+    resources?: ProfilerResourceGauge;
+    backend?: InferenceBackendDiagnostics;
     /** String tags (e.g., handlerType, sourceType, modelId) */
     tags?: Record<string, string>;
 }
 export interface ProfilerRuntimeOptions {
     mode?: 'summary' | 'verbose';
     includeServerBreakdown?: boolean;
+    includeResourceGauges?: boolean;
     operationFilters?: string[];
 }
 export interface AggregatedStats {
@@ -33,6 +38,7 @@ export interface ProfilerExport {
         enabled: boolean;
         mode: 'summary' | 'verbose';
         includeServerBreakdown: boolean;
+        includeResourceGauges: boolean;
         operationFilters: string[];
         maxRecentEvents: number;
     };

package/dist/schemas/audio-gen.d.ts

@@ -0,0 +1,253 @@
+import { z } from 'zod';
+export declare const audioGenRuntimeConfigSchema: z.ZodObject<{
+    useGPU: z.ZodOptional<z.ZodBoolean>;
+    inferenceSteps: z.ZodOptional<z.ZodNumber>;
+    shift: z.ZodOptional<z.ZodNumber>;
+    nGpuLayers: z.ZodOptional<z.ZodNumber>;
+    threads: z.ZodOptional<z.ZodNumber>;
+    backendsDir: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const audioGenConfigSchema: z.ZodObject<{
+    useGPU: z.ZodOptional<z.ZodBoolean>;
+    inferenceSteps: z.ZodOptional<z.ZodNumber>;
+    shift: z.ZodOptional<z.ZodNumber>;
+    nGpuLayers: z.ZodOptional<z.ZodNumber>;
+    threads: z.ZodOptional<z.ZodNumber>;
+    backendsDir: z.ZodOptional<z.ZodString>;
+    textEncModelSrc: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        src: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+        modelId: z.ZodOptional<z.ZodString>;
+        registryPath: z.ZodOptional<z.ZodString>;
+        registrySource: z.ZodOptional<z.ZodString>;
+        blobCoreKey: z.ZodOptional<z.ZodString>;
+        blobIndex: z.ZodOptional<z.ZodNumber>;
+        engine: z.ZodOptional<z.ZodString>;
+        expectedSize: z.ZodOptional<z.ZodNumber>;
+        sha256Checksum: z.ZodOptional<z.ZodString>;
+        addon: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+            embeddings: "embeddings";
+            diffusion: "diffusion";
+            audiogen: "audiogen";
+            tts: "tts";
+            ocr: "ocr";
+            vla: "vla";
+            "llamacpp-completion": "llamacpp-completion";
+            "whispercpp-transcription": "whispercpp-transcription";
+            "bci-whispercpp-transcription": "bci-whispercpp-transcription";
+            "llamacpp-embedding": "llamacpp-embedding";
+            "nmtcpp-translation": "nmtcpp-translation";
+            "onnx-tts": "onnx-tts";
+            "tts-ggml": "tts-ggml";
+            "parakeet-transcription": "parakeet-transcription";
+            "ggml-ocr": "ggml-ocr";
+            "sdcpp-generation": "sdcpp-generation";
+            "audiogen-ggml": "audiogen-ggml";
+            "ggml-vla": "ggml-vla";
+            "ggml-classification": "ggml-classification";
+            llm: "llm";
+            whisper: "whisper";
+            bci: "bci";
+            nmt: "nmt";
+            parakeet: "parakeet";
+            classification: "classification";
+        }>, z.ZodLiteral<"vad">]>>;
+    }, z.core.$strip>]>;
+    lmModelSrc: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        src: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+        modelId: z.ZodOptional<z.ZodString>;
+        registryPath: z.ZodOptional<z.ZodString>;
+        registrySource: z.ZodOptional<z.ZodString>;
+        blobCoreKey: z.ZodOptional<z.ZodString>;
+        blobIndex: z.ZodOptional<z.ZodNumber>;
+        engine: z.ZodOptional<z.ZodString>;
+        expectedSize: z.ZodOptional<z.ZodNumber>;
+        sha256Checksum: z.ZodOptional<z.ZodString>;
+        addon: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+            embeddings: "embeddings";
+            diffusion: "diffusion";
+            audiogen: "audiogen";
+            tts: "tts";
+            ocr: "ocr";
+            vla: "vla";
+            "llamacpp-completion": "llamacpp-completion";
+            "whispercpp-transcription": "whispercpp-transcription";
+            "bci-whispercpp-transcription": "bci-whispercpp-transcription";
+            "llamacpp-embedding": "llamacpp-embedding";
+            "nmtcpp-translation": "nmtcpp-translation";
+            "onnx-tts": "onnx-tts";
+            "tts-ggml": "tts-ggml";
+            "parakeet-transcription": "parakeet-transcription";
+            "ggml-ocr": "ggml-ocr";
+            "sdcpp-generation": "sdcpp-generation";
+            "audiogen-ggml": "audiogen-ggml";
+            "ggml-vla": "ggml-vla";
+            "ggml-classification": "ggml-classification";
+            llm: "llm";
+            whisper: "whisper";
+            bci: "bci";
+            nmt: "nmt";
+            parakeet: "parakeet";
+            classification: "classification";
+        }>, z.ZodLiteral<"vad">]>>;
+    }, z.core.$strip>]>;
+    ditModelSrc: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        src: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+        modelId: z.ZodOptional<z.ZodString>;
+        registryPath: z.ZodOptional<z.ZodString>;
+        registrySource: z.ZodOptional<z.ZodString>;
+        blobCoreKey: z.ZodOptional<z.ZodString>;
+        blobIndex: z.ZodOptional<z.ZodNumber>;
+        engine: z.ZodOptional<z.ZodString>;
+        expectedSize: z.ZodOptional<z.ZodNumber>;
+        sha256Checksum: z.ZodOptional<z.ZodString>;
+        addon: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+            embeddings: "embeddings";
+            diffusion: "diffusion";
+            audiogen: "audiogen";
+            tts: "tts";
+            ocr: "ocr";
+            vla: "vla";
+            "llamacpp-completion": "llamacpp-completion";
+            "whispercpp-transcription": "whispercpp-transcription";
+            "bci-whispercpp-transcription": "bci-whispercpp-transcription";
+            "llamacpp-embedding": "llamacpp-embedding";
+            "nmtcpp-translation": "nmtcpp-translation";
+            "onnx-tts": "onnx-tts";
+            "tts-ggml": "tts-ggml";
+            "parakeet-transcription": "parakeet-transcription";
+            "ggml-ocr": "ggml-ocr";
+            "sdcpp-generation": "sdcpp-generation";
+            "audiogen-ggml": "audiogen-ggml";
+            "ggml-vla": "ggml-vla";
+            "ggml-classification": "ggml-classification";
+            llm: "llm";
+            whisper: "whisper";
+            bci: "bci";
+            nmt: "nmt";
+            parakeet: "parakeet";
+            classification: "classification";
+        }>, z.ZodLiteral<"vad">]>>;
+    }, z.core.$strip>]>;
+    vaeModelSrc: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        src: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+        modelId: z.ZodOptional<z.ZodString>;
+        registryPath: z.ZodOptional<z.ZodString>;
+        registrySource: z.ZodOptional<z.ZodString>;
+        blobCoreKey: z.ZodOptional<z.ZodString>;
+        blobIndex: z.ZodOptional<z.ZodNumber>;
+        engine: z.ZodOptional<z.ZodString>;
+        expectedSize: z.ZodOptional<z.ZodNumber>;
+        sha256Checksum: z.ZodOptional<z.ZodString>;
+        addon: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+            embeddings: "embeddings";
+            diffusion: "diffusion";
+            audiogen: "audiogen";
+            tts: "tts";
+            ocr: "ocr";
+            vla: "vla";
+            "llamacpp-completion": "llamacpp-completion";
+            "whispercpp-transcription": "whispercpp-transcription";
+            "bci-whispercpp-transcription": "bci-whispercpp-transcription";
+            "llamacpp-embedding": "llamacpp-embedding";
+            "nmtcpp-translation": "nmtcpp-translation";
+            "onnx-tts": "onnx-tts";
+            "tts-ggml": "tts-ggml";
+            "parakeet-transcription": "parakeet-transcription";
+            "ggml-ocr": "ggml-ocr";
+            "sdcpp-generation": "sdcpp-generation";
+            "audiogen-ggml": "audiogen-ggml";
+            "ggml-vla": "ggml-vla";
+            "ggml-classification": "ggml-classification";
+            llm: "llm";
+            whisper: "whisper";
+            bci: "bci";
+            nmt: "nmt";
+            parakeet: "parakeet";
+            classification: "classification";
+        }>, z.ZodLiteral<"vad">]>>;
+    }, z.core.$strip>]>;
+}, z.core.$strict>;
+export declare const audioGenClientParamsSchema: z.ZodObject<{
+    modelId: z.ZodString;
+    caption: z.ZodString;
+    lyrics: z.ZodOptional<z.ZodString>;
+    seed: z.ZodOptional<z.ZodNumber>;
+    vocalLanguage: z.ZodOptional<z.ZodString>;
+    bpm: z.ZodOptional<z.ZodNumber>;
+    keyscale: z.ZodOptional<z.ZodString>;
+    timesignature: z.ZodOptional<z.ZodString>;
+    duration: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export declare const audioGenStreamRequestSchema: z.ZodObject<{
+    type: z.ZodLiteral<"audioGenStream">;
+    requestId: z.ZodOptional<z.ZodString>;
+    modelId: z.ZodString;
+    caption: z.ZodString;
+    lyrics: z.ZodOptional<z.ZodString>;
+    seed: z.ZodOptional<z.ZodNumber>;
+    vocalLanguage: z.ZodOptional<z.ZodString>;
+    bpm: z.ZodOptional<z.ZodNumber>;
+    keyscale: z.ZodOptional<z.ZodString>;
+    timesignature: z.ZodOptional<z.ZodString>;
+    duration: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export declare const audioGenProgressSchema: z.ZodObject<{
+    stage: z.ZodString;
+    step: z.ZodNumber;
+    total: z.ZodNumber;
+}, z.core.$strip>;
+export declare const audioGenStatsSchema: z.ZodObject<{
+    audioDurationMs: z.ZodOptional<z.ZodNumber>;
+    totalTimeMs: z.ZodOptional<z.ZodNumber>;
+    realTimeFactor: z.ZodOptional<z.ZodNumber>;
+    backendDevice: z.ZodOptional<z.ZodNumber>;
+    backendId: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const audioGenStreamResponseSchema: z.ZodObject<{
+    type: z.ZodLiteral<"audioGenStream">;
+    progress: z.ZodOptional<z.ZodObject<{
+        stage: z.ZodString;
+        step: z.ZodNumber;
+        total: z.ZodNumber;
+    }, z.core.$strip>>;
+    data: z.ZodOptional<z.ZodString>;
+    sampleRate: z.ZodOptional<z.ZodNumber>;
+    channels: z.ZodOptional<z.ZodNumber>;
+    bitsPerSample: z.ZodOptional<z.ZodNumber>;
+    done: z.ZodDefault<z.ZodBoolean>;
+    stopReason: z.ZodOptional<z.ZodEnum<{
+        cancelled: "cancelled";
+        completed: "completed";
+    }>>;
+    stats: z.ZodOptional<z.ZodObject<{
+        audioDurationMs: z.ZodOptional<z.ZodNumber>;
+        totalTimeMs: z.ZodOptional<z.ZodNumber>;
+        realTimeFactor: z.ZodOptional<z.ZodNumber>;
+        backendDevice: z.ZodOptional<z.ZodNumber>;
+        backendId: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strict>;
+export type AudioGenRuntimeConfig = z.infer<typeof audioGenRuntimeConfigSchema>;
+export type AudioGenConfig = z.infer<typeof audioGenConfigSchema>;
+export type AudioGenClientParams = z.input<typeof audioGenClientParamsSchema>;
+export type AudioGenStreamRequest = z.infer<typeof audioGenStreamRequestSchema>;
+export type AudioGenProgress = z.infer<typeof audioGenProgressSchema>;
+export type AudioGenStats = z.infer<typeof audioGenStatsSchema>;
+export type AudioGenStreamResponse = z.infer<typeof audioGenStreamResponseSchema>;
+export interface AudioGenAudio {
+    pcm: Uint8Array;
+    sampleRate: number;
+    channels: number;
+    bitsPerSample: number;
+}
+export interface AudioGenResult {
+    requestId: string;
+    progressStream: AsyncGenerator<AudioGenProgress>;
+    audio: Promise<AudioGenAudio>;
+    stats: Promise<AudioGenStats | undefined>;
+}
+//# sourceMappingURL=audio-gen.d.ts.map