@qvac/sdk 0.6.0 → 0.7.0

package/dist/schemas/plugin.js

@@ -0,0 +1,132 @@
+import { z } from "zod";
+// Non-streaming plugin invoke
+export const pluginInvokeRequestSchema = z.object({
+    type: z.literal("pluginInvoke"),
+    modelId: z.string(),
+    handler: z.string(),
+    params: z.unknown(),
+});
+export const pluginInvokeResponseSchema = z.object({
+    type: z.literal("pluginInvoke"),
+    result: z.unknown(),
+});
+// Streaming plugin invoke
+export const pluginInvokeStreamRequestSchema = z.object({
+    type: z.literal("pluginInvokeStream"),
+    modelId: z.string(),
+    handler: z.string(),
+    params: z.unknown(),
+});
+export const pluginInvokeStreamResponseSchema = z.object({
+    type: z.literal("pluginInvokeStream"),
+    result: z.unknown(),
+    done: z.boolean().optional(),
+});
+// ============================================
+// Type Helpers
+// ============================================
+/**
+ * Helper function to define a plugin with full type inference.
+ * This is an identity function that provides type checking.
+ */
+export function definePlugin(plugin) {
+    return plugin;
+}
+/**
+ * Helper function to define a handler with full type inference.
+ * This is an identity function that provides type checking.
+ */
+export function defineHandler(definition) {
+    return definition;
+}
+// ============================================
+// Worker runtime validation
+// ============================================
+const functionRuntimeSchema = z.instanceof(Function, {
+    error: "must be a function",
+});
+const zodSchemaLikeRuntimeSchema = z
+    .object({
+    safeParse: functionRuntimeSchema,
+})
+    .catchall(z.unknown());
+export const pluginHandlerDefinitionRuntimeSchema = z
+    .object({
+    requestSchema: zodSchemaLikeRuntimeSchema,
+    responseSchema: zodSchemaLikeRuntimeSchema,
+    streaming: z.boolean({ error: "streaming must be a boolean" }),
+    handler: functionRuntimeSchema,
+})
+    .catchall(z.unknown());
+export const pluginDefinitionRuntimeSchema = z
+    .object({
+    modelType: z
+        .string({ error: "modelType must be a string" })
+        .min(1, "modelType must be a non-empty string"),
+    displayName: z
+        .string({ error: "displayName must be a string" })
+        .min(1, "displayName must be a non-empty string"),
+    addonPackage: z
+        .string({ error: "addonPackage must be a string" })
+        .min(1, "addonPackage must be a non-empty string"),
+    createModel: functionRuntimeSchema,
+    handlers: z.record(z.string(), pluginHandlerDefinitionRuntimeSchema),
+    logging: z
+        .object({
+        module: z.unknown().optional(),
+        namespace: z.string().optional(),
+    })
+        .catchall(z.unknown())
+        .optional(),
+})
+    .catchall(z.unknown());
+// ============================================
+// Built-in Plugins
+// ============================================
+/**
+ * LLM text completion plugin (llama.cpp).
+ * Provides: completion, streaming chat, tool calling.
+ */
+export const PLUGIN_LLM = "@qvac/sdk/llamacpp-completion/plugin";
+/**
+ * Text embedding plugin (llama.cpp).
+ * Provides: vector embeddings for RAG and semantic search.
+ */
+export const PLUGIN_EMBEDDING = "@qvac/sdk/llamacpp-embedding/plugin";
+/**
+ * Speech-to-text transcription plugin (whisper.cpp).
+ * Provides: audio transcription, language detection.
+ */
+export const PLUGIN_WHISPER = "@qvac/sdk/whispercpp-transcription/plugin";
+/**
+ * Neural machine translation plugin (nmt.cpp).
+ * Provides: text translation between languages.
+ */
+export const PLUGIN_NMT = "@qvac/sdk/nmtcpp-translation/plugin";
+/**
+ * Text-to-speech synthesis plugin (ONNX).
+ * Provides: speech synthesis from text.
+ */
+export const PLUGIN_TTS = "@qvac/sdk/onnx-tts/plugin";
+/**
+ * Optical character recognition plugin (ONNX).
+ * Provides: text extraction from images.
+ */
+export const PLUGIN_OCR = "@qvac/sdk/onnx-ocr/plugin";
+/**
+ * All built-in SDK plugins.
+ *
+ * @example
+ * // Use all defaults plus a custom plugin:
+ * const config = {
+ *   plugins: [...SDK_DEFAULT_PLUGINS, myCustomPlugin],
+ * };
+ */
+export const SDK_DEFAULT_PLUGINS = [
+    PLUGIN_LLM,
+    PLUGIN_EMBEDDING,
+    PLUGIN_WHISPER,
+    PLUGIN_NMT,
+    PLUGIN_TTS,
+    PLUGIN_OCR,
+];

package/dist/schemas/rag.d.ts

@@ -79,7 +79,7 @@ export declare const ragCloseWorkspaceParamsSchema: z.ZodObject<{
     deleteOnClose: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
 export declare const ragDeleteWorkspaceParamsSchema: z.ZodObject<{
-    workspace: z.ZodString;
+    workspace: z.ZodPipe<z.ZodString, z.ZodString>;
 }, z.core.$strip>;
 export declare const ragRequestSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     documents: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
@@ -170,7 +170,7 @@ export declare const ragRequestSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     type: z.ZodLiteral<"rag">;
     operation: z.ZodLiteral<"closeWorkspace">;
 }, z.core.$strip>, z.ZodObject<{
-    workspace: z.ZodString;
+    workspace: z.ZodPipe<z.ZodString, z.ZodString>;
     type: z.ZodLiteral<"rag">;
     operation: z.ZodLiteral<"deleteWorkspace">;
 }, z.core.$strip>], "operation">;

package/dist/schemas/rag.js

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { safePathComponent } from "./path-validation.js";
 // ============== Common Schemas ==============
 const llmChunkOptsSchema = z.object({
     chunkSize: z.number().optional(),
@@ -18,7 +19,7 @@ const saveEmbeddingsResultSchema = z.object({
 // modelId is optional - only needed if no cached RAG instance exists
 const ragStorageOnlyBaseSchema = z.object({
     modelId: z.string().optional(),
-    workspace: z.string().optional(),
+    workspace: safePathComponent.optional(),
 });
 // For operations that need the embedding model (ingest, search)
 const ragBaseSchema = ragStorageOnlyBaseSchema.extend({
@@ -111,7 +112,7 @@ const ragListWorkspacesOperationSchema = z.object({
 });
 // ============== Close Workspace Operation ==============
 export const ragCloseWorkspaceParamsSchema = z.object({
-    workspace: z.string().optional(),
+    workspace: safePathComponent.optional(),
     deleteOnClose: z.boolean().optional(),
 });
 const ragCloseWorkspaceOperationSchema = ragCloseWorkspaceParamsSchema.extend({
@@ -120,7 +121,10 @@ const ragCloseWorkspaceOperationSchema = ragCloseWorkspaceParamsSchema.extend({
 });
 // ============== Delete Workspace Operation ==============
 export const ragDeleteWorkspaceParamsSchema = z.object({
-    workspace: z.string().min(1, "Workspace name cannot be empty"),
+    workspace: z
+        .string()
+        .min(1, "Workspace name cannot be empty")
+        .pipe(safePathComponent),
 });
 const ragDeleteWorkspaceOperationSchema = ragDeleteWorkspaceParamsSchema.extend({
     type: z.literal("rag"),

package/dist/schemas/registry.d.ts

@@ -0,0 +1,338 @@
+import { z } from "zod";
+declare const modelRegistryEntryAddonSchema: z.ZodEnum<{
+    llm: "llm";
+    whisper: "whisper";
+    embeddings: "embeddings";
+    nmt: "nmt";
+    tts: "tts";
+    ocr: "ocr";
+    vad: "vad";
+    other: "other";
+}>;
+export declare const modelRegistryEngineSchema: z.ZodEnum<{
+    "llamacpp-completion": "llamacpp-completion";
+    "whispercpp-transcription": "whispercpp-transcription";
+    "llamacpp-embedding": "llamacpp-embedding";
+    "nmtcpp-translation": "nmtcpp-translation";
+    "onnx-tts": "onnx-tts";
+    "onnx-ocr": "onnx-ocr";
+    "onnx-vad": "onnx-vad";
+}>;
+export declare const modelRegistryEntrySchema: z.ZodObject<{
+    name: z.ZodString;
+    registryPath: z.ZodString;
+    registrySource: z.ZodString;
+    blobCoreKey: z.ZodString;
+    blobBlockOffset: z.ZodNumber;
+    blobBlockLength: z.ZodNumber;
+    blobByteOffset: z.ZodNumber;
+    modelId: z.ZodString;
+    addon: z.ZodEnum<{
+        llm: "llm";
+        whisper: "whisper";
+        embeddings: "embeddings";
+        nmt: "nmt";
+        tts: "tts";
+        ocr: "ocr";
+        vad: "vad";
+        other: "other";
+    }>;
+    expectedSize: z.ZodNumber;
+    sha256Checksum: z.ZodString;
+    engine: z.ZodEnum<{
+        "llamacpp-completion": "llamacpp-completion";
+        "whispercpp-transcription": "whispercpp-transcription";
+        "llamacpp-embedding": "llamacpp-embedding";
+        "nmtcpp-translation": "nmtcpp-translation";
+        "onnx-tts": "onnx-tts";
+        "onnx-ocr": "onnx-ocr";
+        "onnx-vad": "onnx-vad";
+    }>;
+    quantization: z.ZodString;
+    params: z.ZodString;
+}, z.core.$strip>;
+export type ModelRegistryEntry = z.infer<typeof modelRegistryEntrySchema>;
+export type ModelRegistryEntryAddon = z.infer<typeof modelRegistryEntryAddonSchema>;
+export type ModelRegistryEngine = z.infer<typeof modelRegistryEngineSchema>;
+export declare const modelRegistryListRequestSchema: z.ZodObject<{
+    type: z.ZodLiteral<"modelRegistryList">;
+}, z.core.$strip>;
+export declare const modelRegistryListResponseSchema: z.ZodObject<{
+    type: z.ZodLiteral<"modelRegistryList">;
+    success: z.ZodBoolean;
+    models: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        registryPath: z.ZodString;
+        registrySource: z.ZodString;
+        blobCoreKey: z.ZodString;
+        blobBlockOffset: z.ZodNumber;
+        blobBlockLength: z.ZodNumber;
+        blobByteOffset: z.ZodNumber;
+        modelId: z.ZodString;
+        addon: z.ZodEnum<{
+            llm: "llm";
+            whisper: "whisper";
+            embeddings: "embeddings";
+            nmt: "nmt";
+            tts: "tts";
+            ocr: "ocr";
+            vad: "vad";
+            other: "other";
+        }>;
+        expectedSize: z.ZodNumber;
+        sha256Checksum: z.ZodString;
+        engine: z.ZodEnum<{
+            "llamacpp-completion": "llamacpp-completion";
+            "whispercpp-transcription": "whispercpp-transcription";
+            "llamacpp-embedding": "llamacpp-embedding";
+            "nmtcpp-translation": "nmtcpp-translation";
+            "onnx-tts": "onnx-tts";
+            "onnx-ocr": "onnx-ocr";
+            "onnx-vad": "onnx-vad";
+        }>;
+        quantization: z.ZodString;
+        params: z.ZodString;
+    }, z.core.$strip>>>;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ModelRegistryListRequest = z.infer<typeof modelRegistryListRequestSchema>;
+export type ModelRegistryListResponse = z.infer<typeof modelRegistryListResponseSchema>;
+export declare const modelRegistrySearchRequestSchema: z.ZodObject<{
+    type: z.ZodLiteral<"modelRegistrySearch">;
+    filter: z.ZodOptional<z.ZodString>;
+    engine: z.ZodOptional<z.ZodString>;
+    quantization: z.ZodOptional<z.ZodString>;
+    addon: z.ZodOptional<z.ZodEnum<{
+        llm: "llm";
+        whisper: "whisper";
+        embeddings: "embeddings";
+        nmt: "nmt";
+        tts: "tts";
+        ocr: "ocr";
+        vad: "vad";
+        other: "other";
+    }>>;
+}, z.core.$strip>;
+export declare const modelRegistrySearchResponseSchema: z.ZodObject<{
+    type: z.ZodLiteral<"modelRegistrySearch">;
+    success: z.ZodBoolean;
+    models: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        registryPath: z.ZodString;
+        registrySource: z.ZodString;
+        blobCoreKey: z.ZodString;
+        blobBlockOffset: z.ZodNumber;
+        blobBlockLength: z.ZodNumber;
+        blobByteOffset: z.ZodNumber;
+        modelId: z.ZodString;
+        addon: z.ZodEnum<{
+            llm: "llm";
+            whisper: "whisper";
+            embeddings: "embeddings";
+            nmt: "nmt";
+            tts: "tts";
+            ocr: "ocr";
+            vad: "vad";
+            other: "other";
+        }>;
+        expectedSize: z.ZodNumber;
+        sha256Checksum: z.ZodString;
+        engine: z.ZodEnum<{
+            "llamacpp-completion": "llamacpp-completion";
+            "whispercpp-transcription": "whispercpp-transcription";
+            "llamacpp-embedding": "llamacpp-embedding";
+            "nmtcpp-translation": "nmtcpp-translation";
+            "onnx-tts": "onnx-tts";
+            "onnx-ocr": "onnx-ocr";
+            "onnx-vad": "onnx-vad";
+        }>;
+        quantization: z.ZodString;
+        params: z.ZodString;
+    }, z.core.$strip>>>;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ModelRegistrySearchRequest = z.infer<typeof modelRegistrySearchRequestSchema>;
+export type ModelRegistrySearchResponse = z.infer<typeof modelRegistrySearchResponseSchema>;
+export declare const modelRegistryGetModelRequestSchema: z.ZodObject<{
+    type: z.ZodLiteral<"modelRegistryGetModel">;
+    registryPath: z.ZodString;
+    registrySource: z.ZodString;
+}, z.core.$strip>;
+export declare const modelRegistryGetModelResponseSchema: z.ZodObject<{
+    type: z.ZodLiteral<"modelRegistryGetModel">;
+    success: z.ZodBoolean;
+    model: z.ZodOptional<z.ZodObject<{
+        name: z.ZodString;
+        registryPath: z.ZodString;
+        registrySource: z.ZodString;
+        blobCoreKey: z.ZodString;
+        blobBlockOffset: z.ZodNumber;
+        blobBlockLength: z.ZodNumber;
+        blobByteOffset: z.ZodNumber;
+        modelId: z.ZodString;
+        addon: z.ZodEnum<{
+            llm: "llm";
+            whisper: "whisper";
+            embeddings: "embeddings";
+            nmt: "nmt";
+            tts: "tts";
+            ocr: "ocr";
+            vad: "vad";
+            other: "other";
+        }>;
+        expectedSize: z.ZodNumber;
+        sha256Checksum: z.ZodString;
+        engine: z.ZodEnum<{
+            "llamacpp-completion": "llamacpp-completion";
+            "whispercpp-transcription": "whispercpp-transcription";
+            "llamacpp-embedding": "llamacpp-embedding";
+            "nmtcpp-translation": "nmtcpp-translation";
+            "onnx-tts": "onnx-tts";
+            "onnx-ocr": "onnx-ocr";
+            "onnx-vad": "onnx-vad";
+        }>;
+        quantization: z.ZodString;
+        params: z.ZodString;
+    }, z.core.$strip>>;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ModelRegistryGetModelRequest = z.infer<typeof modelRegistryGetModelRequestSchema>;
+export type ModelRegistryGetModelResponse = z.infer<typeof modelRegistryGetModelResponseSchema>;
+export declare const modelRegistryRequestSchema: z.ZodUnion<readonly [z.ZodObject<{
+    type: z.ZodLiteral<"modelRegistryList">;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"modelRegistrySearch">;
+    filter: z.ZodOptional<z.ZodString>;
+    engine: z.ZodOptional<z.ZodString>;
+    quantization: z.ZodOptional<z.ZodString>;
+    addon: z.ZodOptional<z.ZodEnum<{
+        llm: "llm";
+        whisper: "whisper";
+        embeddings: "embeddings";
+        nmt: "nmt";
+        tts: "tts";
+        ocr: "ocr";
+        vad: "vad";
+        other: "other";
+    }>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"modelRegistryGetModel">;
+    registryPath: z.ZodString;
+    registrySource: z.ZodString;
+}, z.core.$strip>]>;
+export declare const modelRegistryResponseSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"modelRegistryList">;
+    success: z.ZodBoolean;
+    models: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        registryPath: z.ZodString;
+        registrySource: z.ZodString;
+        blobCoreKey: z.ZodString;
+        blobBlockOffset: z.ZodNumber;
+        blobBlockLength: z.ZodNumber;
+        blobByteOffset: z.ZodNumber;
+        modelId: z.ZodString;
+        addon: z.ZodEnum<{
+            llm: "llm";
+            whisper: "whisper";
+            embeddings: "embeddings";
+            nmt: "nmt";
+            tts: "tts";
+            ocr: "ocr";
+            vad: "vad";
+            other: "other";
+        }>;
+        expectedSize: z.ZodNumber;
+        sha256Checksum: z.ZodString;
+        engine: z.ZodEnum<{
+            "llamacpp-completion": "llamacpp-completion";
+            "whispercpp-transcription": "whispercpp-transcription";
+            "llamacpp-embedding": "llamacpp-embedding";
+            "nmtcpp-translation": "nmtcpp-translation";
+            "onnx-tts": "onnx-tts";
+            "onnx-ocr": "onnx-ocr";
+            "onnx-vad": "onnx-vad";
+        }>;
+        quantization: z.ZodString;
+        params: z.ZodString;
+    }, z.core.$strip>>>;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"modelRegistrySearch">;
+    success: z.ZodBoolean;
+    models: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        registryPath: z.ZodString;
+        registrySource: z.ZodString;
+        blobCoreKey: z.ZodString;
+        blobBlockOffset: z.ZodNumber;
+        blobBlockLength: z.ZodNumber;
+        blobByteOffset: z.ZodNumber;
+        modelId: z.ZodString;
+        addon: z.ZodEnum<{
+            llm: "llm";
+            whisper: "whisper";
+            embeddings: "embeddings";
+            nmt: "nmt";
+            tts: "tts";
+            ocr: "ocr";
+            vad: "vad";
+            other: "other";
+        }>;
+        expectedSize: z.ZodNumber;
+        sha256Checksum: z.ZodString;
+        engine: z.ZodEnum<{
+            "llamacpp-completion": "llamacpp-completion";
+            "whispercpp-transcription": "whispercpp-transcription";
+            "llamacpp-embedding": "llamacpp-embedding";
+            "nmtcpp-translation": "nmtcpp-translation";
+            "onnx-tts": "onnx-tts";
+            "onnx-ocr": "onnx-ocr";
+            "onnx-vad": "onnx-vad";
+        }>;
+        quantization: z.ZodString;
+        params: z.ZodString;
+    }, z.core.$strip>>>;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"modelRegistryGetModel">;
+    success: z.ZodBoolean;
+    model: z.ZodOptional<z.ZodObject<{
+        name: z.ZodString;
+        registryPath: z.ZodString;
+        registrySource: z.ZodString;
+        blobCoreKey: z.ZodString;
+        blobBlockOffset: z.ZodNumber;
+        blobBlockLength: z.ZodNumber;
+        blobByteOffset: z.ZodNumber;
+        modelId: z.ZodString;
+        addon: z.ZodEnum<{
+            llm: "llm";
+            whisper: "whisper";
+            embeddings: "embeddings";
+            nmt: "nmt";
+            tts: "tts";
+            ocr: "ocr";
+            vad: "vad";
+            other: "other";
+        }>;
+        expectedSize: z.ZodNumber;
+        sha256Checksum: z.ZodString;
+        engine: z.ZodEnum<{
+            "llamacpp-completion": "llamacpp-completion";
+            "whispercpp-transcription": "whispercpp-transcription";
+            "llamacpp-embedding": "llamacpp-embedding";
+            "nmtcpp-translation": "nmtcpp-translation";
+            "onnx-tts": "onnx-tts";
+            "onnx-ocr": "onnx-ocr";
+            "onnx-vad": "onnx-vad";
+        }>;
+        quantization: z.ZodString;
+        params: z.ZodString;
+    }, z.core.$strip>>;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>], "type">;
+export type ModelRegistryRequest = z.infer<typeof modelRegistryRequestSchema>;
+export type ModelRegistryResponse = z.infer<typeof modelRegistryResponseSchema>;
+export {};
+//# sourceMappingURL=registry.d.ts.map

package/dist/schemas/registry.js

@@ -0,0 +1,91 @@
+import { z } from "zod";
+import { ModelType } from "./model-types.js";
+// QVAC Model Registry entry schema matching the RegistryItem from models/registry/models.ts
+const modelRegistryEntryAddonSchema = z.enum([
+    "llm",
+    "whisper",
+    "embeddings",
+    "nmt",
+    "vad",
+    "tts",
+    "ocr",
+    "other",
+]);
+// Canonical engine names derived from ModelType (schemas/model-types.ts) plus
+// registry-only engines not present in ModelType.
+// Values reference ModelType.* directly to avoid string duplication.
+// The SDK resolves legacy engine names (e.g. @qvac/* package names) to canonical
+// form via schemas/engine-addon-map.ts.
+export const modelRegistryEngineSchema = z.enum([
+    ModelType.llamacppCompletion,
+    ModelType.whispercppTranscription,
+    ModelType.llamacppEmbedding,
+    ModelType.nmtcppTranslation,
+    ModelType.onnxTts,
+    ModelType.onnxOcr,
+    "onnx-vad",
+]);
+export const modelRegistryEntrySchema = z.object({
+    name: z.string(),
+    registryPath: z.string(),
+    registrySource: z.string(),
+    blobCoreKey: z.string(),
+    blobBlockOffset: z.number(),
+    blobBlockLength: z.number(),
+    blobByteOffset: z.number(),
+    modelId: z.string(),
+    addon: modelRegistryEntryAddonSchema,
+    expectedSize: z.number(),
+    sha256Checksum: z.string(),
+    engine: modelRegistryEngineSchema,
+    quantization: z.string(),
+    params: z.string(),
+});
+// QVAC Model Registry list request/response
+export const modelRegistryListRequestSchema = z.object({
+    type: z.literal("modelRegistryList"),
+});
+export const modelRegistryListResponseSchema = z.object({
+    type: z.literal("modelRegistryList"),
+    success: z.boolean(),
+    models: z.array(modelRegistryEntrySchema).optional(),
+    error: z.string().optional(),
+});
+// QVAC Model Registry search request/response
+export const modelRegistrySearchRequestSchema = z.object({
+    type: z.literal("modelRegistrySearch"),
+    filter: z.string().optional(),
+    engine: z.string().optional(),
+    quantization: z.string().optional(),
+    addon: modelRegistryEntryAddonSchema.optional(),
+});
+export const modelRegistrySearchResponseSchema = z.object({
+    type: z.literal("modelRegistrySearch"),
+    success: z.boolean(),
+    models: z.array(modelRegistryEntrySchema).optional(),
+    error: z.string().optional(),
+});
+// QVAC Model Registry get model request/response
+export const modelRegistryGetModelRequestSchema = z.object({
+    type: z.literal("modelRegistryGetModel"),
+    registryPath: z.string(),
+    registrySource: z.string(),
+});
+export const modelRegistryGetModelResponseSchema = z.object({
+    type: z.literal("modelRegistryGetModel"),
+    success: z.boolean(),
+    model: modelRegistryEntrySchema.optional(),
+    error: z.string().optional(),
+});
+// Combined QVAC Model Registry request union
+export const modelRegistryRequestSchema = z.union([
+    modelRegistryListRequestSchema,
+    modelRegistrySearchRequestSchema,
+    modelRegistryGetModelRequestSchema,
+]);
+// Combined QVAC Model Registry response union
+export const modelRegistryResponseSchema = z.discriminatedUnion("type", [
+    modelRegistryListResponseSchema,
+    modelRegistrySearchResponseSchema,
+    modelRegistryGetModelResponseSchema,
+]);

package/dist/schemas/sdk-errors-client.d.ts

@@ -3,16 +3,14 @@ export declare const SDK_CLIENT_ERROR_CODES: {
     readonly INVALID_RESPONSE_TYPE: 50001;
     readonly INVALID_OPERATION_IN_RESPONSE: 50002;
     readonly STREAM_ENDED_WITHOUT_RESPONSE: 50003;
-    readonly NO_DATA_RECEIVED: 50004;
-    readonly INVALID_AUDIO_CHUNK_TYPE: 50005;
-    readonly INVALID_TOOLS_ARRAY: 50006;
-    readonly INVALID_TOOL_SCHEMA: 50007;
-    readonly OCR_FAILED: 50008;
+    readonly INVALID_AUDIO_CHUNK_TYPE: 50004;
+    readonly INVALID_TOOLS_ARRAY: 50005;
+    readonly INVALID_TOOL_SCHEMA: 50006;
+    readonly OCR_FAILED: 50007;
     readonly RPC_NO_HANDLER: 50200;
     readonly RPC_REQUEST_NOT_SENT: 50201;
     readonly RPC_RESPONSE_STREAM_NOT_CREATED: 50202;
     readonly RPC_CONNECTION_FAILED: 50203;
-    readonly UNKNOWN_REQUEST_TYPE: 50204;
     readonly PROVIDER_START_FAILED: 50400;
     readonly PROVIDER_STOP_FAILED: 50401;
     readonly DELEGATE_NO_FINAL_RESPONSE: 50402;
@@ -24,6 +22,8 @@ export declare const SDK_CLIENT_ERROR_CODES: {
     readonly CONFIG_FILE_INVALID: 50603;
     readonly CONFIG_FILE_PARSE_FAILED: 50604;
     readonly CONFIG_VALIDATION_FAILED: 50605;
+    readonly PEAR_WORKER_ENTRY_REQUIRED: 50606;
+    readonly MULTIPLE_SDK_INSTALLATIONS: 50607;
 };
 declare const clientErrorDefinitions: ErrorCodesMap;
 export { clientErrorDefinitions as SDK_CLIENT_ERROR_DEFINITIONS };