@qvac/sdk 0.14.1 → 0.15.0

package/dist/schemas/profiling.js

@@ -1,21 +1,21 @@
-import { z } from "zod";
+import { z } from 'zod';
 /** Internal envelope key for profiling metadata in RPC payloads */
-export const PROFILING_KEY = "__profiling";
+export const PROFILING_KEY = '__profiling';
 /** Marker key for profiling-only trailer frames in streaming responses */
-export const PROFILING_TRAILER_KEY = "__profilingTrailer";
+export const PROFILING_TRAILER_KEY = '__profilingTrailer';
 /**
  * Symbol key for attaching delegation breakdown to response objects.
  */
-export const DELEGATION_BREAKDOWN_KEY = Symbol.for("@qvac/sdk:delegation-breakdown");
+export const DELEGATION_BREAKDOWN_KEY = Symbol.for('@qvac/sdk:delegation-breakdown');
 /**
  * Symbol key for attaching operation event to response objects.
  */
-export const OPERATION_EVENT_KEY = Symbol.for("@qvac/sdk:operation-event");
+export const OPERATION_EVENT_KEY = Symbol.for('@qvac/sdk:operation-event');
 /**
  * Symbol key for attaching model execution timing.
  */
-export const MODEL_EXECUTION_KEY = Symbol.for("@qvac/sdk:model-execution");
-export const profilerModeSchema = z.enum(["summary", "verbose"]);
+export const MODEL_EXECUTION_KEY = Symbol.for('@qvac/sdk:model-execution');
+export const profilerModeSchema = z.enum(['summary', 'verbose']);
 /**
  * Server-side timing breakdown (server → client).
  * Attached to profiling response when includeServerBreakdown is enabled.
@@ -26,7 +26,7 @@ export const serverBreakdownSchema = z.object({
     handlerExecutionMs: z.number().optional(),
     responseZodValidationMs: z.number().optional(),
     responseStringifyMs: z.number().optional(),
-    totalServerMs: z.number().optional(),
+    totalServerMs: z.number().optional()
 });
 /**
  * Delegation timing breakdown (consumer server → client).
@@ -40,39 +40,39 @@ export const delegationBreakdownSchema = z.object({
     requestStringifyMs: z.number().optional(),
     serverWaitMs: z.number().optional(),
     responseJsonParseMs: z.number().optional(),
-    totalDelegationMs: z.number().optional(),
+    totalDelegationMs: z.number().optional()
 });
 export const operationEventSchema = z.object({
     op: z.string(),
-    kind: z.literal("handler"),
+    kind: z.literal('handler'),
     ms: z.number(),
     profileId: z.string().optional(),
     gauges: z.record(z.string(), z.number()).optional(),
     tags: z.record(z.string(), z.string()).optional(),
-    count: z.number().optional(),
+    count: z.number().optional()
 });
 export const profilingRequestMetaSchema = z.object({
     enabled: z.boolean().optional(),
     id: z.string().optional(),
     includeServer: z.boolean().optional(),
-    mode: profilerModeSchema.optional(),
+    mode: profilerModeSchema.optional()
 });
 export const profilingResponseMetaSchema = z.object({
     id: z.string(),
     server: serverBreakdownSchema.optional(),
     delegation: delegationBreakdownSchema.optional(),
-    operation: operationEventSchema.optional(),
+    operation: operationEventSchema.optional()
 });
 export const perCallProfilingSchema = z.object({
     enabled: z
         .boolean()
         .optional()
-        .describe("Enable profiling for this call only; when omitted, the SDK-level profiler configuration applies."),
+        .describe('Enable profiling for this call only; when omitted, the SDK-level profiler configuration applies.'),
     includeServerBreakdown: z
         .boolean()
         .optional()
-        .describe("Include server-side timing breakdown in the profiling payload."),
+        .describe('Include server-side timing breakdown in the profiling payload.'),
     mode: profilerModeSchema
         .optional()
-        .describe('Profiling detail level: `"summary"` aggregates only, `"verbose"` retains recent events.'),
+        .describe('Profiling detail level: `"summary"` aggregates only, `"verbose"` retains recent events.')
 });

package/dist/schemas/provide.d.ts

@@ -1,4 +1,4 @@
-import { z } from "zod";
+import { z } from 'zod';
 export declare const firewallConfigSchema: z.ZodObject<{
     mode: z.ZodDefault<z.ZodEnum<{
         allow: "allow";

package/dist/schemas/provide.js

@@ -1,22 +1,22 @@
-import { z } from "zod";
+import { z } from 'zod';
 export const firewallConfigSchema = z.object({
-    mode: z.enum(["allow", "deny"]).default("allow"),
-    publicKeys: z.array(z.string()).default([]),
+    mode: z.enum(['allow', 'deny']).default('allow'),
+    publicKeys: z.array(z.string()).default([])
 });
 export const provideParamsSchema = z
     .object({
-    firewall: firewallConfigSchema.optional(),
+    firewall: firewallConfigSchema.optional()
 })
     .strict();
 export const provideRequestSchema = provideParamsSchema.extend({
-    type: z.literal("provide"),
+    type: z.literal('provide')
 });
 export const provideResponseSchema = z.object({
-    type: z.literal("provide"),
+    type: z.literal('provide'),
     success: z.boolean(),
     error: z.string().optional(),
-    publicKey: z.string().optional(),
+    publicKey: z.string().optional()
 });
 export const envSchema = z.object({
-    QVAC_HYPERSWARM_SEED: z.string(),
+    QVAC_HYPERSWARM_SEED: z.string()
 });

package/dist/schemas/rag.d.ts

@@ -1,5 +1,5 @@
-import { z } from "zod";
-import type { Doc, EmbeddedDoc, SaveEmbeddingsResult, SearchResult, ReindexResult, IngestResult, IngestStage, ReindexStage, SaveStage } from "@qvac/rag";
+import { z } from 'zod';
+import type { Doc, EmbeddedDoc, SaveEmbeddingsResult, SearchResult, ReindexResult, IngestResult, IngestStage, ReindexStage, SaveStage } from '@qvac/rag';
 export declare const ragIngestParamsSchema: z.ZodObject<{
     workspace: z.ZodOptional<z.ZodString>;
     modelId: z.ZodString;
@@ -298,5 +298,5 @@ export type RagReindexParams = z.input<typeof ragReindexParamsSchema> & {
 export type RagCloseWorkspaceParams = z.infer<typeof ragCloseWorkspaceParamsSchema>;
 export type RagDeleteWorkspaceParams = z.infer<typeof ragDeleteWorkspaceParamsSchema>;
 export type RagWorkspaceInfo = z.infer<typeof ragWorkspaceInfoSchema>;
-export type { Doc as RagDoc, EmbeddedDoc as RagEmbeddedDoc, SaveEmbeddingsResult as RagSaveEmbeddingsResult, SearchResult as RagSearchResult, ReindexResult as RagReindexResult, IngestStage as RagIngestStage, ReindexStage as RagReindexStage, SaveStage as RagSaveStage, IngestResult as RagIngestResult, };
+export type { Doc as RagDoc, EmbeddedDoc as RagEmbeddedDoc, SaveEmbeddingsResult as RagSaveEmbeddingsResult, SearchResult as RagSearchResult, ReindexResult as RagReindexResult, IngestStage as RagIngestStage, ReindexStage as RagReindexStage, SaveStage as RagSaveStage, IngestResult as RagIngestResult };
 //# sourceMappingURL=rag.d.ts.map

package/dist/schemas/rag.js

@@ -1,29 +1,27 @@
-import { z } from "zod";
-import { safePathComponent } from "./path-validation.js";
+import { z } from 'zod';
+import { safePathComponent } from './path-validation.js';
 // ============== Common Schemas ==============
 const llmChunkOptsSchema = z.object({
     chunkSize: z.number().optional(),
     chunkOverlap: z.number().optional(),
-    chunkStrategy: z.enum(["character", "paragraph"]).optional(),
-    splitStrategy: z
-        .enum(["character", "word", "token", "sentence", "line"])
-        .optional(),
+    chunkStrategy: z.enum(['character', 'paragraph']).optional(),
+    splitStrategy: z.enum(['character', 'word', 'token', 'sentence', 'line']).optional()
 });
 const saveEmbeddingsResultSchema = z.object({
-    status: z.enum(["fulfilled", "rejected"]),
+    status: z.enum(['fulfilled', 'rejected']),
     id: z.string().optional(),
-    error: z.string().optional(),
+    error: z.string().optional()
 });
 // ============== Base Schemas ==============
 // For storage-only operations (reindex, delete, saveEmbeddings)
 // modelId is optional - only needed if no cached RAG instance exists
 const ragStorageOnlyBaseSchema = z.object({
     modelId: z.string().optional(),
-    workspace: safePathComponent.optional(),
+    workspace: safePathComponent.optional()
 });
 // For operations that need the embedding model (ingest, search)
 const ragBaseSchema = ragStorageOnlyBaseSchema.extend({
-    modelId: z.string(),
+    modelId: z.string()
 });
 // ============== Ingest Operation ==============
 export const ragIngestParamsSchema = ragBaseSchema.extend({
@@ -32,24 +30,24 @@ export const ragIngestParamsSchema = ragBaseSchema.extend({
     chunkOpts: llmChunkOptsSchema.optional(),
     progressInterval: z.number().positive().optional(),
     onProgress: z.unknown().optional(),
-    withProgress: z.boolean().optional(),
+    withProgress: z.boolean().optional()
 });
 const ragIngestOperationSchema = ragIngestParamsSchema.extend({
-    type: z.literal("rag"),
-    operation: z.literal("ingest"),
+    type: z.literal('rag'),
+    operation: z.literal('ingest')
 });
 // ============== Chunk Operation ==============
 const docSchema = z.object({
     id: z.string(),
-    content: z.string(),
+    content: z.string()
 });
 export const ragChunkParamsSchema = z.object({
     documents: z.union([z.string(), z.array(z.string())]),
-    chunkOpts: llmChunkOptsSchema.optional(),
+    chunkOpts: llmChunkOptsSchema.optional()
 });
 const ragChunkOperationSchema = ragChunkParamsSchema.extend({
-    type: z.literal("rag"),
-    operation: z.literal("chunk"),
+    type: z.literal('rag'),
+    operation: z.literal('chunk')
 });
 // ============== SaveEmbeddings Operation ==============
 const embeddedDocSchema = z.object({
@@ -57,78 +55,75 @@ const embeddedDocSchema = z.object({
     content: z.string(),
     embedding: z.array(z.number()),
     embeddingModelId: z.string(),
-    metadata: z.record(z.string(), z.unknown()).optional(),
+    metadata: z.record(z.string(), z.unknown()).optional()
 });
 export const ragSaveEmbeddingsParamsSchema = ragStorageOnlyBaseSchema.extend({
     documents: z.array(embeddedDocSchema),
     progressInterval: z.number().positive().optional(),
     onProgress: z.unknown().optional(),
-    withProgress: z.boolean().optional(),
+    withProgress: z.boolean().optional()
 });
 const ragSaveEmbeddingsOperationSchema = ragSaveEmbeddingsParamsSchema.extend({
-    type: z.literal("rag"),
-    operation: z.literal("saveEmbeddings"),
+    type: z.literal('rag'),
+    operation: z.literal('saveEmbeddings')
 });
 // ============== Reindex Operation ==============
 const reindexResultSchema = z.object({
     reindexed: z.boolean(),
-    details: z.record(z.string(), z.unknown()).optional(),
+    details: z.record(z.string(), z.unknown()).optional()
 });
 export const ragReindexParamsSchema = ragStorageOnlyBaseSchema.extend({
     onProgress: z.unknown().optional(),
-    withProgress: z.boolean().optional(),
+    withProgress: z.boolean().optional()
 });
 const ragReindexOperationSchema = ragReindexParamsSchema.extend({
-    type: z.literal("rag"),
-    operation: z.literal("reindex"),
+    type: z.literal('rag'),
+    operation: z.literal('reindex')
 });
 // ============== Search Operation ==============
 const searchResultSchema = z.object({
     id: z.string(),
     content: z.string(),
-    score: z.number(),
+    score: z.number()
 });
 export const ragSearchParamsSchema = ragBaseSchema.extend({
-    query: z.string().min(1, "Query cannot be empty"),
+    query: z.string().min(1, 'Query cannot be empty'),
     topK: z.number().positive().default(5),
-    n: z.number().positive().default(3),
+    n: z.number().positive().default(3)
 });
 const ragSearchOperationSchema = ragSearchParamsSchema.extend({
-    type: z.literal("rag"),
-    operation: z.literal("search"),
+    type: z.literal('rag'),
+    operation: z.literal('search')
 });
 // ============== Delete Embeddings Operation ==============
 export const ragDeleteEmbeddingsParamsSchema = ragStorageOnlyBaseSchema.extend({
-    ids: z.array(z.string()).min(1, "At least one ID must be provided"),
+    ids: z.array(z.string()).min(1, 'At least one ID must be provided')
 });
 const ragDeleteEmbeddingsOperationSchema = ragDeleteEmbeddingsParamsSchema.extend({
-    type: z.literal("rag"),
-    operation: z.literal("deleteEmbeddings"),
+    type: z.literal('rag'),
+    operation: z.literal('deleteEmbeddings')
 });
 // ============== List Workspaces Operation ==============
 const ragListWorkspacesOperationSchema = z.object({
-    type: z.literal("rag"),
-    operation: z.literal("listWorkspaces"),
+    type: z.literal('rag'),
+    operation: z.literal('listWorkspaces')
 });
 // ============== Close Workspace Operation ==============
 export const ragCloseWorkspaceParamsSchema = z.object({
     workspace: safePathComponent.optional(),
-    deleteOnClose: z.boolean().optional(),
+    deleteOnClose: z.boolean().optional()
 });
 const ragCloseWorkspaceOperationSchema = ragCloseWorkspaceParamsSchema.extend({
-    type: z.literal("rag"),
-    operation: z.literal("closeWorkspace"),
+    type: z.literal('rag'),
+    operation: z.literal('closeWorkspace')
 });
 // ============== Delete Workspace Operation ==============
 export const ragDeleteWorkspaceParamsSchema = z.object({
-    workspace: z
-        .string()
-        .min(1, "Workspace name cannot be empty")
-        .pipe(safePathComponent),
+    workspace: z.string().min(1, 'Workspace name cannot be empty').pipe(safePathComponent)
 });
 const ragDeleteWorkspaceOperationSchema = ragDeleteWorkspaceParamsSchema.extend({
-    type: z.literal("rag"),
-    operation: z.literal("deleteWorkspace"),
+    type: z.literal('rag'),
+    operation: z.literal('deleteWorkspace')
 });
 // ============== Unified Request Schema ==============
 // `requestId` is threaded onto every RAG operation as an optional field so
@@ -137,9 +132,9 @@ const ragDeleteWorkspaceOperationSchema = ragDeleteWorkspaceParamsSchema.extend(
 // so legacy clients keep working — the server falls back to a
 // server-generated id when the field is missing.
 const ragRequestIdField = {
-    requestId: z.string().min(1).optional(),
+    requestId: z.string().min(1).optional()
 };
-export const ragRequestSchema = z.discriminatedUnion("operation", [
+export const ragRequestSchema = z.discriminatedUnion('operation', [
     ragChunkOperationSchema.extend(ragRequestIdField),
     ragIngestOperationSchema.extend(ragRequestIdField),
     ragSaveEmbeddingsOperationSchema.extend(ragRequestIdField),
@@ -148,53 +143,53 @@ export const ragRequestSchema = z.discriminatedUnion("operation", [
     ragReindexOperationSchema.extend(ragRequestIdField),
     ragListWorkspacesOperationSchema.extend(ragRequestIdField),
     ragCloseWorkspaceOperationSchema.extend(ragRequestIdField),
-    ragDeleteWorkspaceOperationSchema.extend(ragRequestIdField),
+    ragDeleteWorkspaceOperationSchema.extend(ragRequestIdField)
 ]);
 // ============== Response Schemas ==============
 const ragResponseBaseSchema = z.object({
-    type: z.literal("rag"),
+    type: z.literal('rag'),
     success: z.boolean(),
-    error: z.string().optional(),
+    error: z.string().optional()
 });
 const ragChunkResponseSchema = ragResponseBaseSchema.extend({
-    operation: z.literal("chunk"),
-    chunks: z.array(docSchema),
+    operation: z.literal('chunk'),
+    chunks: z.array(docSchema)
 });
 const ragIngestResponseSchema = ragResponseBaseSchema.extend({
-    operation: z.literal("ingest"),
+    operation: z.literal('ingest'),
     processed: z.array(saveEmbeddingsResultSchema),
-    droppedIndices: z.array(z.number()),
+    droppedIndices: z.array(z.number())
 });
 const ragSaveEmbeddingsResponseSchema = ragResponseBaseSchema.extend({
-    operation: z.literal("saveEmbeddings"),
-    processed: z.array(saveEmbeddingsResultSchema),
+    operation: z.literal('saveEmbeddings'),
+    processed: z.array(saveEmbeddingsResultSchema)
 });
 const ragSearchResponseSchema = ragResponseBaseSchema.extend({
-    operation: z.literal("search"),
-    results: z.array(searchResultSchema),
+    operation: z.literal('search'),
+    results: z.array(searchResultSchema)
 });
 const ragDeleteEmbeddingsResponseSchema = ragResponseBaseSchema.extend({
-    operation: z.literal("deleteEmbeddings"),
+    operation: z.literal('deleteEmbeddings')
 });
 const ragReindexResponseSchema = ragResponseBaseSchema.extend({
-    operation: z.literal("reindex"),
-    result: reindexResultSchema,
+    operation: z.literal('reindex'),
+    result: reindexResultSchema
 });
 const ragWorkspaceInfoSchema = z.object({
     name: z.string(),
-    open: z.boolean(),
+    open: z.boolean()
 });
 const ragListWorkspacesResponseSchema = ragResponseBaseSchema.extend({
-    operation: z.literal("listWorkspaces"),
-    workspaces: z.array(ragWorkspaceInfoSchema),
+    operation: z.literal('listWorkspaces'),
+    workspaces: z.array(ragWorkspaceInfoSchema)
 });
 const ragCloseWorkspaceResponseSchema = ragResponseBaseSchema.extend({
-    operation: z.literal("closeWorkspace"),
+    operation: z.literal('closeWorkspace')
 });
 const ragDeleteWorkspaceResponseSchema = ragResponseBaseSchema.extend({
-    operation: z.literal("deleteWorkspace"),
+    operation: z.literal('deleteWorkspace')
 });
-export const ragResponseSchema = z.discriminatedUnion("operation", [
+export const ragResponseSchema = z.discriminatedUnion('operation', [
     ragChunkResponseSchema,
     ragIngestResponseSchema,
     ragSaveEmbeddingsResponseSchema,
@@ -203,15 +198,15 @@ export const ragResponseSchema = z.discriminatedUnion("operation", [
     ragReindexResponseSchema,
     ragListWorkspacesResponseSchema,
     ragCloseWorkspaceResponseSchema,
-    ragDeleteWorkspaceResponseSchema,
+    ragDeleteWorkspaceResponseSchema
 ]);
 // ============== Progress Update Schema ==============
 export const ragProgressUpdateSchema = z.object({
-    type: z.literal("rag:progress"),
-    operation: z.enum(["ingest", "saveEmbeddings", "reindex"]),
+    type: z.literal('rag:progress'),
+    operation: z.enum(['ingest', 'saveEmbeddings', 'reindex']),
     workspace: z.string(),
     stage: z.string(),
     current: z.number(),
     total: z.number(),
-    timestamp: z.number(),
+    timestamp: z.number()
 });

package/dist/schemas/registry.d.ts

@@ -1,4 +1,4 @@
-import { z } from "zod";
+import { z } from 'zod';
 declare const modelRegistryEntryAddonSchema: z.ZodEnum<{
     embeddings: "embeddings";
     diffusion: "diffusion";

package/dist/schemas/registry.js

@@ -1,20 +1,20 @@
-import { z } from "zod";
-import { ModelType } from "./model-types.js";
+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",
-    "bci",
-    "embeddings",
-    "nmt",
-    "vad",
-    "tts",
-    "ocr",
-    "parakeet",
-    "diffusion",
-    "vla",
-    "classification",
-    "other",
+    'llm',
+    'whisper',
+    'bci',
+    'embeddings',
+    'nmt',
+    'vad',
+    'tts',
+    'ocr',
+    'parakeet',
+    'diffusion',
+    'vla',
+    'classification',
+    'other'
 ]);
 // Canonical engine names derived from ModelType (schemas/model-types.ts) plus
 // registry-only engines not present in ModelType.
@@ -34,91 +34,69 @@ export const modelRegistryEngineSchema = z.enum([
     ModelType.sdcppGeneration,
     ModelType.ggmlVla,
     ModelType.ggmlClassification,
-    "onnx-vad",
+    'onnx-vad'
 ]);
 export const modelRegistryEntrySchema = z.object({
-    name: z.string().describe("Catalog name of the model entry."),
-    registryPath: z
-        .string()
-        .describe("Registry-relative path to the model."),
-    registrySource: z
-        .string()
-        .describe("Registry source identifier, e.g. `huggingface`."),
-    blobCoreKey: z
-        .string()
-        .describe("Hyperdrive blob core key for the model file."),
-    blobBlockOffset: z
-        .number()
-        .describe("Starting block offset of the model file in the blob."),
-    blobBlockLength: z
-        .number()
-        .describe("Number of blocks occupied by the model file."),
-    blobByteOffset: z
-        .number()
-        .describe("Starting byte offset of the model file within its block."),
-    modelId: z
-        .string()
-        .describe("Unique identifier used to reference the model in SDK calls."),
-    addon: modelRegistryEntryAddonSchema.describe("Inference addon / capability category this model belongs to."),
-    expectedSize: z
-        .number()
-        .describe("Expected total size of the model file in bytes."),
-    sha256Checksum: z
-        .string()
-        .describe("Expected SHA-256 checksum of the model file."),
-    engine: modelRegistryEngineSchema.describe("Canonical inference engine identifier."),
-    quantization: z
-        .string()
-        .describe("Quantization identifier, e.g. `Q4_K_M`."),
-    params: z
-        .string()
-        .describe("Parameter-count label for the model, e.g. `7B`."),
+    name: z.string().describe('Catalog name of the model entry.'),
+    registryPath: z.string().describe('Registry-relative path to the model.'),
+    registrySource: z.string().describe('Registry source identifier, e.g. `huggingface`.'),
+    blobCoreKey: z.string().describe('Hyperdrive blob core key for the model file.'),
+    blobBlockOffset: z.number().describe('Starting block offset of the model file in the blob.'),
+    blobBlockLength: z.number().describe('Number of blocks occupied by the model file.'),
+    blobByteOffset: z.number().describe('Starting byte offset of the model file within its block.'),
+    modelId: z.string().describe('Unique identifier used to reference the model in SDK calls.'),
+    addon: modelRegistryEntryAddonSchema.describe('Inference addon / capability category this model belongs to.'),
+    expectedSize: z.number().describe('Expected total size of the model file in bytes.'),
+    sha256Checksum: z.string().describe('Expected SHA-256 checksum of the model file.'),
+    engine: modelRegistryEngineSchema.describe('Canonical inference engine identifier.'),
+    quantization: z.string().describe('Quantization identifier, e.g. `Q4_K_M`.'),
+    params: z.string().describe('Parameter-count label for the model, e.g. `7B`.')
 });
 // QVAC Model Registry list request/response
 export const modelRegistryListRequestSchema = z.object({
-    type: z.literal("modelRegistryList"),
+    type: z.literal('modelRegistryList')
 });
 export const modelRegistryListResponseSchema = z.object({
-    type: z.literal("modelRegistryList"),
+    type: z.literal('modelRegistryList'),
     success: z.boolean(),
     models: z.array(modelRegistryEntrySchema).optional(),
-    error: z.string().optional(),
+    error: z.string().optional()
 });
 // QVAC Model Registry search request/response
 export const modelRegistrySearchRequestSchema = z.object({
-    type: z.literal("modelRegistrySearch"),
+    type: z.literal('modelRegistrySearch'),
     filter: z.string().optional(),
     engine: z.string().optional(),
     quantization: z.string().optional(),
-    addon: modelRegistryEntryAddonSchema.optional(),
+    addon: modelRegistryEntryAddonSchema.optional()
 });
 export const modelRegistrySearchResponseSchema = z.object({
-    type: z.literal("modelRegistrySearch"),
+    type: z.literal('modelRegistrySearch'),
     success: z.boolean(),
     models: z.array(modelRegistryEntrySchema).optional(),
-    error: z.string().optional(),
+    error: z.string().optional()
 });
 // QVAC Model Registry get model request/response
 export const modelRegistryGetModelRequestSchema = z.object({
-    type: z.literal("modelRegistryGetModel"),
+    type: z.literal('modelRegistryGetModel'),
     registryPath: z.string(),
-    registrySource: z.string(),
+    registrySource: z.string()
 });
 export const modelRegistryGetModelResponseSchema = z.object({
-    type: z.literal("modelRegistryGetModel"),
+    type: z.literal('modelRegistryGetModel'),
     success: z.boolean(),
     model: modelRegistryEntrySchema.optional(),
-    error: z.string().optional(),
+    error: z.string().optional()
 });
 // Combined QVAC Model Registry request union
 export const modelRegistryRequestSchema = z.union([
     modelRegistryListRequestSchema,
     modelRegistrySearchRequestSchema,
-    modelRegistryGetModelRequestSchema,
+    modelRegistryGetModelRequestSchema
 ]);
 // Combined QVAC Model Registry response union
-export const modelRegistryResponseSchema = z.discriminatedUnion("type", [
+export const modelRegistryResponseSchema = z.discriminatedUnion('type', [
     modelRegistryListResponseSchema,
     modelRegistrySearchResponseSchema,
-    modelRegistryGetModelResponseSchema,
+    modelRegistryGetModelResponseSchema
 ]);

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

@@ -1,4 +1,4 @@
-import { z } from "zod";
+import { z } from 'zod';
 export declare const modelIdSchema: z.ZodString;
 export declare const reloadConfigOptionsSchema: z.ZodUnion<readonly [z.ZodObject<{
     modelId: z.ZodString;

package/dist/schemas/reload-config.js

@@ -1,44 +1,40 @@
-import { z } from "zod";
-import { whisperConfigSchema } from "./transcription-config.js";
-import { whisperModelTypeSchema } from "./model-types.js";
-export const modelIdSchema = z
-    .string()
-    .regex(/^[0-9a-f]{16}$/, "Invalid modelId format");
+import { z } from 'zod';
+import { whisperConfigSchema } from './transcription-config.js';
+import { whisperModelTypeSchema } from './model-types.js';
+export const modelIdSchema = z.string().regex(/^[0-9a-f]{16}$/, 'Invalid modelId format');
 export const reloadConfigOptionsSchema = z.union([
     z.object({
         modelId: modelIdSchema,
         modelType: whisperModelTypeSchema,
-        modelConfig: whisperConfigSchema.partial().strict(),
-    }),
+        modelConfig: whisperConfigSchema.partial().strict()
+    })
 ]);
 export const reloadConfigOptionsToRequestSchema = z.union([
     z
         .object({
         modelId: modelIdSchema,
         modelType: whisperModelTypeSchema,
-        modelConfig: whisperConfigSchema.partial().strict(),
+        modelConfig: whisperConfigSchema.partial().strict()
     })
         .transform((data) => ({
-        type: "loadModel",
+        type: 'loadModel',
         modelId: data.modelId,
         modelType: data.modelType,
-        modelConfig: data.modelConfig,
-    })),
+        modelConfig: data.modelConfig
+    }))
 ]);
 const reloadConfigRequestBaseSchema = z.object({
-    type: z.literal("loadModel"),
+    type: z.literal('loadModel'),
     modelId: modelIdSchema,
     // Explicitly exclude load-specific fields for type narrowing
     modelSrc: z.never().optional(),
     withProgress: z.never().optional(),
     delegate: z.never().optional(),
-    seed: z.never().optional(),
+    seed: z.never().optional()
 });
 export const reloadConfigWhisperRequestSchema = reloadConfigRequestBaseSchema.extend({
     modelType: whisperModelTypeSchema,
-    modelConfig: whisperConfigSchema.partial(),
+    modelConfig: whisperConfigSchema.partial()
 });
 // Using z.union since modelType accepts multiple values
-export const reloadConfigRequestSchema = z.union([
-    reloadConfigWhisperRequestSchema,
-]);
+export const reloadConfigRequestSchema = z.union([reloadConfigWhisperRequestSchema]);