@qvac/sdk 0.14.0 → 0.15.0

package/dist/schemas/engine-addon-map.d.ts

@@ -1,4 +1,4 @@
-import { type ModelRegistryEngine, type ModelRegistryEntryAddon } from "./registry";
+import { type ModelRegistryEngine, type ModelRegistryEntryAddon } from './registry';
 export declare const ENGINE_TO_ADDON: {
     readonly "llamacpp-completion": "llm";
     readonly "whispercpp-transcription": "whisper";
@@ -12,7 +12,7 @@ export declare const ENGINE_TO_ADDON: {
     readonly "sdcpp-generation": "diffusion";
     readonly "ggml-vla": "vla";
     readonly "ggml-classification": "classification";
-    readonly "onnx-vad": "vad";
+    readonly 'onnx-vad': "vad";
 };
 export declare function resolveCanonicalEngine(engine: string): ModelRegistryEngine | null;
 export declare function getAddonFromEngine(engine: ModelRegistryEngine): ModelRegistryEntryAddon;

package/dist/schemas/engine-addon-map.js

@@ -1,22 +1,22 @@
-import { ModelType } from "./model-types.js";
-import { ADDON_BCI, ADDON_CLASSIFICATION, ADDON_DIFFUSION, ADDON_EMBEDDING, ADDON_LLM, ADDON_NMT, ADDON_OCR, ADDON_PARAKEET, ADDON_TTS, ADDON_VLA, ADDON_WHISPER, } from "./plugin.js";
-import { modelRegistryEngineSchema, } from "./registry.js";
+import { ModelType } from './model-types.js';
+import { ADDON_BCI, ADDON_CLASSIFICATION, ADDON_DIFFUSION, ADDON_EMBEDDING, ADDON_LLM, ADDON_NMT, ADDON_OCR, ADDON_PARAKEET, ADDON_TTS, ADDON_VLA, ADDON_WHISPER } from './plugin.js';
+import { modelRegistryEngineSchema } from './registry.js';
 // Canonical engine → addon mapping (exhaustive). `as const` preserves
 // per-key literals so the addon can be derived from the engine at the type level.
 export const ENGINE_TO_ADDON = {
-    [ModelType.llamacppCompletion]: "llm",
-    [ModelType.whispercppTranscription]: "whisper",
-    [ModelType.bciWhispercppTranscription]: "bci",
-    [ModelType.llamacppEmbedding]: "embeddings",
-    [ModelType.nmtcppTranslation]: "nmt",
-    [ModelType.onnxTts]: "tts",
-    [ModelType.ttsGgml]: "tts",
-    [ModelType.ggmlOcr]: "ocr",
-    [ModelType.parakeetTranscription]: "parakeet",
-    [ModelType.sdcppGeneration]: "diffusion",
-    [ModelType.ggmlVla]: "vla",
-    [ModelType.ggmlClassification]: "classification",
-    "onnx-vad": "vad",
+    [ModelType.llamacppCompletion]: 'llm',
+    [ModelType.whispercppTranscription]: 'whisper',
+    [ModelType.bciWhispercppTranscription]: 'bci',
+    [ModelType.llamacppEmbedding]: 'embeddings',
+    [ModelType.nmtcppTranslation]: 'nmt',
+    [ModelType.onnxTts]: 'tts',
+    [ModelType.ttsGgml]: 'tts',
+    [ModelType.ggmlOcr]: 'ocr',
+    [ModelType.parakeetTranscription]: 'parakeet',
+    [ModelType.sdcppGeneration]: 'diffusion',
+    [ModelType.ggmlVla]: 'vla',
+    [ModelType.ggmlClassification]: 'classification',
+    'onnx-vad': 'vad'
 };
 // Legacy engine names → canonical engine.
 // Used for backward compatibility with old registry data that uses @qvac/* package names.
@@ -29,21 +29,21 @@ const LEGACY_ENGINE_TO_CANONICAL = {
     [ADDON_TTS]: ModelType.ttsGgml,
     [ADDON_OCR]: ModelType.ggmlOcr,
     // Pre-GGML package / tag names from the ONNX era — resolve to the GGML engine.
-    "@qvac/ocr-onnx": ModelType.ggmlOcr,
-    "onnx-ocr": ModelType.ggmlOcr,
+    '@qvac/ocr-onnx': ModelType.ggmlOcr,
+    'onnx-ocr': ModelType.ggmlOcr,
     [ADDON_PARAKEET]: ModelType.parakeetTranscription,
-    "@qvac/translation-llamacpp": ModelType.nmtcppTranslation,
-    "@qvac/vad-silero": "onnx-vad",
+    '@qvac/translation-llamacpp': ModelType.nmtcppTranslation,
+    '@qvac/vad-silero': 'onnx-vad',
     // Legacy package / tag names from the ONNX era — resolve to the GGML engine.
-    "@qvac/tts": ModelType.ttsGgml,
-    "@qvac/tts-onnx": ModelType.ttsGgml,
+    '@qvac/tts': ModelType.ttsGgml,
+    '@qvac/tts-onnx': ModelType.ttsGgml,
     // Tag-style names (used by some older registry entries)
     generation: ModelType.llamacppCompletion,
     transcription: ModelType.whispercppTranscription,
     bci: ModelType.bciWhispercppTranscription,
     embedding: ModelType.llamacppEmbedding,
     translation: ModelType.nmtcppTranslation,
-    vad: "onnx-vad",
+    vad: 'onnx-vad',
     tts: ModelType.ttsGgml,
     ocr: ModelType.ggmlOcr,
     [ADDON_DIFFUSION]: ModelType.sdcppGeneration,
@@ -51,7 +51,7 @@ const LEGACY_ENGINE_TO_CANONICAL = {
     [ADDON_VLA]: ModelType.ggmlVla,
     vla: ModelType.ggmlVla,
     [ADDON_CLASSIFICATION]: ModelType.ggmlClassification,
-    classification: ModelType.ggmlClassification,
+    classification: ModelType.ggmlClassification
 };
 // Resolves any engine string (legacy or canonical) to a validated canonical engine.
 // Returns null if the engine is not recognized.

package/dist/schemas/error.d.ts

@@ -1,4 +1,4 @@
-import { z } from "zod";
+import { z } from 'zod';
 /**
  * Wire shape for errors thrown across the RPC boundary. The fields are
  * the union of (a) the legacy `QvacErrorBase` serialisation (`name`,

package/dist/schemas/error.js

@@ -1,6 +1,6 @@
-import { z } from "zod";
-import { QvacErrorBase } from "@qvac/error";
-import { formatZodError } from "../utils/zod-error.js";
+import { z } from 'zod';
+import { QvacErrorBase } from '@qvac/error';
+import { formatZodError } from '../utils/zod-error.js';
 /**
  * Wire shape for errors thrown across the RPC boundary. The fields are
  * the union of (a) the legacy `QvacErrorBase` serialisation (`name`,
@@ -18,21 +18,20 @@ import { formatZodError } from "../utils/zod-error.js";
  * side; the schema itself doesn't change.
  */
 export const errorResponseSchema = z.object({
-    type: z.literal("error"),
+    type: z.literal('error'),
     message: z.string(),
     stack: z.string().optional(),
     timestamp: z.string().optional(),
     name: z.string().optional(),
     code: z.number().optional(),
     cause: z.unknown().optional(),
-    typedFields: z.record(z.string(), z.unknown()).optional(),
+    typedFields: z.record(z.string(), z.unknown()).optional()
 });
 function hasTypedFields(error) {
     return (error !== null &&
-        typeof error === "object" &&
-        "toErrorResponseFields" in error &&
-        typeof error
-            .toErrorResponseFields === "function");
+        typeof error === 'object' &&
+        'toErrorResponseFields' in error &&
+        typeof error.toErrorResponseFields === 'function');
 }
 function isQvacError(error) {
     return error instanceof QvacErrorBase;
@@ -41,12 +40,12 @@ export function createErrorResponse(error) {
     if (isQvacError(error)) {
         const qvacData = error.toJSON();
         const response = {
-            type: "error",
+            type: 'error',
             name: qvacData.name,
             code: qvacData.code,
             message: qvacData.message,
             stack: qvacData.stack,
-            timestamp: new Date().toISOString(),
+            timestamp: new Date().toISOString()
         };
         if (hasTypedFields(error)) {
             response.typedFields = error.toErrorResponseFields();
@@ -60,9 +59,9 @@ export function createErrorResponse(error) {
             : String(error);
     const stack = error instanceof Error ? error.stack : undefined;
     return {
-        type: "error",
+        type: 'error',
         message,
         stack,
-        timestamp: new Date().toISOString(),
+        timestamp: new Date().toISOString()
     };
 }

package/dist/schemas/finetune.d.ts

@@ -1,4 +1,4 @@
-import { z } from "zod";
+import { z } from 'zod';
 export declare const finetuneValidationSchema: z.ZodPipe<z.ZodDiscriminatedUnion<[z.ZodObject<{
     type: z.ZodLiteral<"none">;
 }, z.core.$strict>, z.ZodObject<{

package/dist/schemas/finetune.js

@@ -1,43 +1,37 @@
-import { z } from "zod";
-const lrSchedulerValues = ["constant", "cosine", "linear"];
-const finetuneStatusValues = [
-    "IDLE",
-    "RUNNING",
-    "PAUSED",
-    "CANCELLED",
-    "COMPLETED",
-];
+import { z } from 'zod';
+const lrSchedulerValues = ['constant', 'cosine', 'linear'];
+const finetuneStatusValues = ['IDLE', 'RUNNING', 'PAUSED', 'CANCELLED', 'COMPLETED'];
 export const finetuneValidationSchema = z
-    .discriminatedUnion("type", [
+    .discriminatedUnion('type', [
     z
         .object({
-        type: z.literal("none"),
+        type: z.literal('none')
     })
         .strict(),
     z
         .object({
-        type: z.literal("split"),
-        fraction: z.number().min(0).max(1).optional(),
+        type: z.literal('split'),
+        fraction: z.number().min(0).max(1).optional()
     })
         .strict(),
     z
         .object({
-        type: z.literal("dataset"),
-        path: z.string().min(1, "Validation dataset path cannot be empty"),
+        type: z.literal('dataset'),
+        path: z.string().min(1, 'Validation dataset path cannot be empty')
     })
-        .strict(),
+        .strict()
 ])
-    .transform((validation) => validation.type === "split"
+    .transform((validation) => validation.type === 'split'
     ? {
         ...validation,
-        fraction: validation.fraction ?? 0.05,
+        fraction: validation.fraction ?? 0.05
     }
     : validation);
 const finetuneOptionsPayloadSchema = z
     .object({
-    trainDatasetDir: z.string().min(1, "Training dataset path cannot be empty"),
+    trainDatasetDir: z.string().min(1, 'Training dataset path cannot be empty'),
     validation: finetuneValidationSchema,
-    outputParametersDir: z.string().min(1, "Output parameters path cannot be empty"),
+    outputParametersDir: z.string().min(1, 'Output parameters path cannot be empty'),
     numberOfEpochs: z.number().int().positive().optional(),
     learningRate: z.number().positive().optional(),
     contextLength: z.number().int().positive().optional(),
@@ -58,67 +52,67 @@ const finetuneOptionsPayloadSchema = z
     warmupRatioSet: z.boolean().optional(),
     warmupSteps: z.number().int().min(0).optional(),
     warmupStepsSet: z.boolean().optional(),
-    weightDecay: z.number().min(0).optional(),
+    weightDecay: z.number().min(0).optional()
 })
     .strict();
 const finetuneModelParamsSchema = z
     .object({
-    modelId: z.string(),
+    modelId: z.string()
 })
     .strict();
 const finetuneRunParamsSchemaBase = finetuneModelParamsSchema
     .extend({
-    options: finetuneOptionsPayloadSchema,
+    options: finetuneOptionsPayloadSchema
 })
     .strict();
 export const finetuneRunParamsSchema = finetuneRunParamsSchemaBase
     .extend({
-    operation: z.enum(["start", "resume"]).optional(),
+    operation: z.enum(['start', 'resume']).optional()
 })
     .strict();
 export const finetuneGetStateParamsSchema = finetuneRunParamsSchemaBase
     .extend({
-    operation: z.literal("getState"),
+    operation: z.literal('getState')
 })
     .strict();
 export const finetuneStopParamsSchema = finetuneModelParamsSchema
     .extend({
-    operation: z.enum(["pause", "cancel"]),
+    operation: z.enum(['pause', 'cancel'])
 })
     .strict();
 export const finetuneParamsSchema = z.union([
     finetuneRunParamsSchema,
     finetuneGetStateParamsSchema,
-    finetuneStopParamsSchema,
+    finetuneStopParamsSchema
 ]);
 export const finetuneRunRequestSchema = finetuneRunParamsSchemaBase
     .extend({
-    type: z.literal("finetune"),
-    operation: z.enum(["start", "resume"]).optional(),
+    type: z.literal('finetune'),
+    operation: z.enum(['start', 'resume']).optional(),
     withProgress: z.boolean().optional(),
     requestId: z
         .string()
         .min(1)
         .optional()
-        .describe("Stable identifier for this in-flight finetune, generated by the client at call time. Surfaces on the registry so callers can target it with `cancel({ requestId })`. Optional on the wire — the server falls back to a server-generated id when the field is missing."),
+        .describe('Stable identifier for this in-flight finetune, generated by the client at call time. Surfaces on the registry so callers can target it with `cancel({ requestId })`. Optional on the wire — the server falls back to a server-generated id when the field is missing.')
 })
     .strict();
 export const finetuneGetStateRequestSchema = finetuneRunParamsSchemaBase
     .extend({
-    type: z.literal("finetune"),
-    operation: z.literal("getState"),
+    type: z.literal('finetune'),
+    operation: z.literal('getState')
 })
     .strict();
 export const finetuneStopRequestSchema = finetuneModelParamsSchema
     .extend({
-    type: z.literal("finetune"),
-    operation: z.enum(["pause", "cancel"]),
+    type: z.literal('finetune'),
+    operation: z.enum(['pause', 'cancel'])
 })
     .strict();
 export const finetuneRequestSchema = z.union([
     finetuneRunRequestSchema,
     finetuneGetStateRequestSchema,
-    finetuneStopRequestSchema,
+    finetuneStopRequestSchema
 ]);
 export const finetuneStatusSchema = z.enum(finetuneStatusValues);
 export const finetuneProgressSchema = z
@@ -133,7 +127,7 @@ export const finetuneProgressSchema = z
     current_batch: z.number().int().min(0),
     total_batches: z.number().int().min(0),
     elapsed_ms: z.number().min(0),
-    eta_ms: z.number().min(0),
+    eta_ms: z.number().min(0)
 })
     .strict();
 export const finetuneStatsSchema = z
@@ -148,19 +142,19 @@ export const finetuneStatsSchema = z
     val_accuracy_uncertainty: z.union([z.number(), z.nan()]).nullable().optional(),
     learning_rate: z.number().optional(),
     global_steps: z.number().int().min(0),
-    epochs_completed: z.number().int().min(0),
+    epochs_completed: z.number().int().min(0)
 })
     .strict();
 export const finetuneResponseSchema = z
     .object({
-    type: z.literal("finetune"),
+    type: z.literal('finetune'),
     status: finetuneStatusSchema,
-    stats: finetuneStatsSchema.optional(),
+    stats: finetuneStatsSchema.optional()
 })
     .strict();
 export const finetuneProgressResponseSchema = finetuneProgressSchema
     .extend({
-    type: z.literal("finetune:progress"),
-    modelId: z.string(),
+    type: z.literal('finetune:progress'),
+    modelId: z.string()
 })
     .strict();

package/dist/schemas/get-loaded-model-info.d.ts

@@ -1,4 +1,4 @@
-import { z } from "zod";
+import { z } from 'zod';
 export declare const getLoadedModelInfoParamsSchema: z.ZodObject<{
     modelId: z.ZodString;
 }, z.core.$strip>;

package/dist/schemas/get-loaded-model-info.js

@@ -1,12 +1,12 @@
-import { z } from "zod";
+import { z } from 'zod';
 export const getLoadedModelInfoParamsSchema = z.object({
-    modelId: z.string(),
+    modelId: z.string()
 });
 export const getLoadedModelInfoRequestSchema = getLoadedModelInfoParamsSchema.extend({
-    type: z.literal("getLoadedModelInfo"),
+    type: z.literal('getLoadedModelInfo')
 });
 const delegatedProviderInfoSchema = z.object({
-    providerPublicKey: z.string(),
+    providerPublicKey: z.string()
 });
 /**
  * Loaded local model: routing plugin known on this node, so modelType +
@@ -21,7 +21,7 @@ const localLoadedModelInfoSchema = z.object({
     addonPackage: z.string().optional(),
     loadedAt: z.coerce.date(),
     name: z.string().optional(),
-    path: z.string().optional(),
+    path: z.string().optional()
 });
 /**
  * Loaded delegated model: this node only stores routing info, so `modelType`,
@@ -32,13 +32,13 @@ const delegatedLoadedModelInfoSchema = z.object({
     modelId: z.string(),
     isDelegated: z.literal(true),
     handlers: z.array(z.string()),
-    providerInfo: delegatedProviderInfoSchema,
+    providerInfo: delegatedProviderInfoSchema
 });
-export const loadedModelInfoSchema = z.discriminatedUnion("isDelegated", [
+export const loadedModelInfoSchema = z.discriminatedUnion('isDelegated', [
     localLoadedModelInfoSchema,
-    delegatedLoadedModelInfoSchema,
+    delegatedLoadedModelInfoSchema
 ]);
 export const getLoadedModelInfoResponseSchema = z.object({
-    type: z.literal("getLoadedModelInfo"),
-    info: loadedModelInfoSchema,
+    type: z.literal('getLoadedModelInfo'),
+    info: loadedModelInfoSchema
 });

package/dist/schemas/get-model-info.d.ts

@@ -1,4 +1,4 @@
-import { z } from "zod";
+import { z } from 'zod';
 export declare const getModelInfoParamsSchema: z.ZodObject<{
     name: z.ZodString;
 }, z.core.$strip>;

package/dist/schemas/get-model-info.js

@@ -1,133 +1,90 @@
-import { z } from "zod";
+import { z } from 'zod';
 export const getModelInfoParamsSchema = z.object({
-    name: z
-        .string()
-        .describe("The model's registry name (as found in the SDK's built-in catalog)."),
+    name: z.string().describe("The model's registry name (as found in the SDK's built-in catalog).")
 });
 export const getModelInfoRequestSchema = getModelInfoParamsSchema.extend({
-    type: z.literal("getModelInfo"),
+    type: z.literal('getModelInfo')
 });
 export const loadedInstanceSchema = z.object({
-    registryId: z
-        .string()
-        .describe("Identifier of the registered loaded instance."),
-    loadedAt: z
-        .coerce.date()
-        .describe("Timestamp when the instance was loaded."),
+    registryId: z.string().describe('Identifier of the registered loaded instance.'),
+    loadedAt: z.coerce.date().describe('Timestamp when the instance was loaded.'),
     config: z
         .unknown()
         .optional()
-        .describe("Opaque model-specific configuration the instance was loaded with."),
+        .describe('Opaque model-specific configuration the instance was loaded with.')
 });
 export const cacheFileInfoSchema = z.object({
-    filename: z.string().describe("Name of the cached file on disk."),
-    path: z.string().describe("Absolute path to the cached file."),
-    expectedSize: z
-        .number()
-        .describe("Expected file size in bytes from the model metadata."),
-    sha256Checksum: z
-        .string()
-        .describe("Expected SHA-256 checksum of the file."),
-    isCached: z
-        .boolean()
-        .describe("Whether the file is currently present in the cache."),
-    actualSize: z
-        .number()
-        .optional()
-        .describe("Actual size of the cached file on disk, in bytes."),
-    cachedAt: z
-        .coerce.date()
-        .optional()
-        .describe("Timestamp when the file was last cached."),
+    filename: z.string().describe('Name of the cached file on disk.'),
+    path: z.string().describe('Absolute path to the cached file.'),
+    expectedSize: z.number().describe('Expected file size in bytes from the model metadata.'),
+    sha256Checksum: z.string().describe('Expected SHA-256 checksum of the file.'),
+    isCached: z.boolean().describe('Whether the file is currently present in the cache.'),
+    actualSize: z.number().optional().describe('Actual size of the cached file on disk, in bytes.'),
+    cachedAt: z.coerce.date().optional().describe('Timestamp when the file was last cached.')
 });
 export const modelInfoSchema = z.object({
-    name: z.string().describe("Catalog name of the model."),
-    modelId: z
-        .string()
-        .describe("Unique identifier used to reference the model in SDK calls."),
+    name: z.string().describe('Catalog name of the model.'),
+    modelId: z.string().describe('Unique identifier used to reference the model in SDK calls.'),
     // Registry-based fields
     registryPath: z
         .string()
         .optional()
-        .describe("Registry-relative path (set for registry-backed models)."),
-    registrySource: z
-        .string()
-        .optional()
-        .describe("Registry source identifier, e.g. `huggingface`."),
-    blobCoreKey: z
-        .string()
-        .optional()
-        .describe("Hyperdrive blob core key for the model file."),
+        .describe('Registry-relative path (set for registry-backed models).'),
+    registrySource: z.string().optional().describe('Registry source identifier, e.g. `huggingface`.'),
+    blobCoreKey: z.string().optional().describe('Hyperdrive blob core key for the model file.'),
     blobBlockOffset: z
         .number()
         .optional()
-        .describe("Starting block offset of the model file in the blob."),
+        .describe('Starting block offset of the model file in the blob.'),
     blobBlockLength: z
         .number()
         .optional()
-        .describe("Number of blocks occupied by the model file in the blob."),
+        .describe('Number of blocks occupied by the model file in the blob.'),
     blobByteOffset: z
         .number()
         .optional()
-        .describe("Starting byte offset of the model file within its block."),
+        .describe('Starting byte offset of the model file within its block.'),
     engine: z
         .string()
         .optional()
-        .describe("Inference engine identifier, e.g. `llamacpp-completion`."),
-    quantization: z
-        .string()
-        .optional()
-        .describe("Quantization identifier, e.g. `Q4_K_M`."),
-    params: z
-        .string()
-        .optional()
-        .describe("Parameter-count label for the model, e.g. `7B`."),
-    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."),
+        .describe('Inference engine identifier, e.g. `llamacpp-completion`.'),
+    quantization: z.string().optional().describe('Quantization identifier, e.g. `Q4_K_M`.'),
+    params: z.string().optional().describe('Parameter-count label for the model, e.g. `7B`.'),
+    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.'),
     addon: z
         .enum([
-        "llm",
-        "whisper",
-        "bci",
-        "parakeet",
-        "embeddings",
-        "nmt",
-        "vad",
-        "tts",
-        "ocr",
-        "diffusion",
-        "vla",
-        "classification",
-        "other",
+        'llm',
+        'whisper',
+        'bci',
+        'parakeet',
+        'embeddings',
+        'nmt',
+        'vad',
+        'tts',
+        'ocr',
+        'diffusion',
+        'vla',
+        'classification',
+        'other'
     ])
-        .describe("Inference addon / capability category this model belongs to."),
-    isCached: z
-        .boolean()
-        .describe("Whether the model file is present in the local cache."),
-    isLoaded: z
-        .boolean()
-        .describe("Whether the model is currently loaded into memory."),
+        .describe('Inference addon / capability category this model belongs to.'),
+    isCached: z.boolean().describe('Whether the model file is present in the local cache.'),
+    isLoaded: z.boolean().describe('Whether the model is currently loaded into memory.'),
     cacheFiles: z
         .array(cacheFileInfoSchema)
-        .describe("Individual cache file entries that make up this model."),
+        .describe('Individual cache file entries that make up this model.'),
     actualSize: z
         .number()
         .optional()
-        .describe("Actual total size of the cached model on disk, in bytes."),
-    cachedAt: z
-        .coerce.date()
-        .optional()
-        .describe("Timestamp when the model was last cached."),
+        .describe('Actual total size of the cached model on disk, in bytes.'),
+    cachedAt: z.coerce.date().optional().describe('Timestamp when the model was last cached.'),
     loadedInstances: z
         .array(loadedInstanceSchema)
         .optional()
-        .describe("Loaded instances associated with this model (one per live load)."),
+        .describe('Loaded instances associated with this model (one per live load).')
 });
 export const getModelInfoResponseSchema = z.object({
-    type: z.literal("getModelInfo"),
-    modelInfo: modelInfoSchema,
+    type: z.literal('getModelInfo'),
+    modelInfo: modelInfoSchema
 });

package/dist/schemas/heartbeat.d.ts

@@ -1,4 +1,4 @@
-import { z } from "zod";
+import { z } from 'zod';
 export declare const heartbeatRequestSchema: z.ZodObject<{
     type: z.ZodLiteral<"heartbeat">;
     delegate: z.ZodOptional<z.ZodObject<{

package/dist/schemas/heartbeat.js

@@ -1,10 +1,10 @@
-import { z } from "zod";
-import { delegateBaseSchema } from "./delegate.js";
+import { z } from 'zod';
+import { delegateBaseSchema } from './delegate.js';
 export const heartbeatRequestSchema = z.object({
-    type: z.literal("heartbeat"),
-    delegate: delegateBaseSchema.optional(),
+    type: z.literal('heartbeat'),
+    delegate: delegateBaseSchema.optional()
 });
 export const heartbeatResponseSchema = z.object({
-    type: z.literal("heartbeat"),
-    number: z.number(),
+    type: z.literal('heartbeat'),
+    number: z.number()
 });