@qvac/sdk 0.3.0 → 0.4.0

package/dist/schemas/common.js

@@ -11,9 +11,12 @@ import { provideRequestSchema, provideResponseSchema } from "./provide.js";
 import { stopProvideRequestSchema, stopProvideResponseSchema, } from "./stop-provide.js";
 import { translateRequestSchema, translateResponseSchema } from "./translate.js";
 import { loggingStreamRequestSchema, loggingStreamResponseSchema, } from "./logging-stream.js";
+import { ttsRequestSchema, ttsResponseSchema } from "./text-to-speech.js";
 import { errorResponseSchema } from "./error.js";
 import { ragRequestSchema, ragResponseSchema } from "./rag.js";
 import { deleteCacheRequestSchema, deleteCacheResponseSchema, } from "./delete-cache.js";
+import { setConfigRequestSchema, setConfigResponseSchema } from "./set-config.js";
+import { getModelInfoRequestSchema, getModelInfoResponseSchema, } from "./get-model-info.js";
 export const requestSchema = z.union([
     pingRequestSchema,
     loadModelRequestSchema,
@@ -24,11 +27,14 @@ export const requestSchema = z.union([
     loggingStreamRequestSchema,
     embedRequestSchema,
     translateRequestSchema,
+    ttsRequestSchema,
     cancelRequestSchema,
     provideRequestSchema,
     stopProvideRequestSchema,
     ragRequestSchema,
     deleteCacheRequestSchema,
+    setConfigRequestSchema,
+    getModelInfoRequestSchema,
 ]);
 export const responseSchema = z.discriminatedUnion("type", [
     pingResponseSchema,
@@ -41,12 +47,15 @@ export const responseSchema = z.discriminatedUnion("type", [
     loggingStreamResponseSchema,
     embedResponseSchema,
     translateResponseSchema,
+    ttsResponseSchema,
     cancelResponseSchema,
     provideResponseSchema,
     stopProvideResponseSchema,
     errorResponseSchema,
     ragResponseSchema,
     deleteCacheResponseSchema,
+    setConfigResponseSchema,
+    getModelInfoResponseSchema,
 ]);
 export const rpcOptionsSchema = z.object({
     timeout: z.number().min(100).optional(),

package/dist/schemas/completion-stream.d.ts

@@ -1,25 +1,4 @@
 import { z } from "zod";
-export declare const toolSchema: z.ZodObject<{
-    type: z.ZodLiteral<"function">;
-    name: z.ZodString;
-    description: z.ZodString;
-    parameters: z.ZodObject<{
-        type: z.ZodLiteral<"object">;
-        properties: z.ZodRecord<z.ZodString, z.ZodObject<{
-            type: z.ZodEnum<{
-                string: "string";
-                number: "number";
-                boolean: "boolean";
-                object: "object";
-                array: "array";
-                integer: "integer";
-            }>;
-            description: z.ZodOptional<z.ZodString>;
-            enum: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        }, z.core.$strip>>;
-        required: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    }, z.core.$strip>;
-}, z.core.$strip>;
 export declare const attachmentSchema: z.ZodObject<{
     path: z.ZodString;
 }, z.core.$strip>;
@@ -115,6 +94,32 @@ export declare const completionStreamResponseSchema: z.ZodObject<{
         tokensPerSecond: z.ZodNumber;
         cacheTokens: z.ZodNumber;
     }, z.core.$strip>>;
+    toolCallEvent: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+        type: z.ZodLiteral<"toolCall">;
+        call: z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            arguments: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            raw: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"toolCallError">;
+        error: z.ZodObject<{
+            code: z.ZodEnum<{
+                PARSE_ERROR: "PARSE_ERROR";
+                VALIDATION_ERROR: "VALIDATION_ERROR";
+                UNKNOWN_TOOL: "UNKNOWN_TOOL";
+            }>;
+            message: z.ZodString;
+            raw: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+    }, z.core.$strip>]>>;
+    toolCalls: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        arguments: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        raw: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
     error: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export type CompletionParams = z.infer<typeof completionParamsSchema>;
@@ -122,6 +127,5 @@ export type CompletionClientParams = z.input<typeof completionClientParamsSchema
 export type CompletionStreamRequest = z.infer<typeof completionStreamRequestSchema>;
 export type CompletionStreamResponse = z.infer<typeof completionStreamResponseSchema>;
 export type Attachment = z.infer<typeof attachmentSchema>;
-export type Tool = z.infer<typeof toolSchema>;
 export type CompletionStats = z.infer<typeof completionStatsSchema>;
 //# sourceMappingURL=completion-stream.d.ts.map

package/dist/schemas/completion-stream.js

@@ -1,28 +1,12 @@
 import { z } from "zod";
-export const toolSchema = z.object({
-    type: z.literal("function"),
-    name: z.string(),
-    description: z.string(),
-    parameters: z.object({
-        type: z.literal("object"),
-        properties: z.record(z.string(), z.object({
-            type: z.enum([
-                "string",
-                "number",
-                "integer",
-                "boolean",
-                "object",
-                "array",
-            ]),
-            description: z.string().optional(),
-            enum: z.array(z.string()).optional(),
-        })),
-        required: z.array(z.string()).optional(),
-    }),
-});
+import { toolSchema, toolCallSchema, toolCallEventSchema } from "./tools.js";
 export const attachmentSchema = z.object({
     path: z.string(),
 });
+const kvCacheSchema = z.union([
+    z.boolean(),
+    z.string().min(1, "KV cache key cannot be empty string"),
+]);
 export const completionParamsSchema = z.object({
     history: z.array(z.object({
         role: z.string(),
@@ -30,12 +14,12 @@ export const completionParamsSchema = z.object({
         attachments: z.array(attachmentSchema).optional(),
     })),
     modelId: z.string(),
-    kvCache: z.union([z.boolean(), z.string()]).optional(),
+    kvCache: kvCacheSchema.optional(),
 });
 export const completionClientParamsSchema = completionParamsSchema.extend({
     tools: z.array(toolSchema).optional(),
     stream: z.boolean(),
-    kvCache: z.union([z.boolean(), z.string()]).optional(),
+    kvCache: kvCacheSchema.optional(),
 });
 export const completionStreamRequestSchema = completionClientParamsSchema.extend({
     type: z.literal("completionStream"),
@@ -50,5 +34,7 @@ export const completionStreamResponseSchema = z.object({
     token: z.string(),
     done: z.boolean().optional(),
     stats: completionStatsSchema.optional(),
+    toolCallEvent: toolCallEventSchema.optional(),
+    toolCalls: z.array(toolCallSchema).optional(),
     error: z.string().optional(),
 });

package/dist/schemas/download-asset.d.ts

@@ -1,14 +1,89 @@
 import { z } from "zod";
 import type { ModelProgressUpdate } from "./load-model";
 export declare const downloadAssetOptionsSchema: z.ZodPipe<z.ZodObject<{
-    assetSrc: z.ZodString;
+    assetSrc: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        src: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+        modelId: z.ZodOptional<z.ZodString>;
+        hyperdriveKey: z.ZodOptional<z.ZodString>;
+        hyperbeeKey: z.ZodOptional<z.ZodString>;
+        expectedSize: z.ZodOptional<z.ZodNumber>;
+        sha256Checksum: z.ZodOptional<z.ZodString>;
+        addon: z.ZodOptional<z.ZodEnum<{
+            llm: "llm";
+            whisper: "whisper";
+            embeddings: "embeddings";
+            nmt: "nmt";
+            vad: "vad";
+            tts: "tts";
+        }>>;
+    }, z.core.$strip>]>;
     seed: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>, z.ZodTransform<{
     seed: boolean;
-    assetSrc: string;
+    assetSrc: string | {
+        src: string;
+        name?: string | undefined;
+        modelId?: string | undefined;
+        hyperdriveKey?: string | undefined;
+        hyperbeeKey?: string | undefined;
+        expectedSize?: number | undefined;
+        sha256Checksum?: string | undefined;
+        addon?: "llm" | "whisper" | "embeddings" | "nmt" | "vad" | "tts" | undefined;
+    };
 }, {
+    assetSrc: string | {
+        src: string;
+        name?: string | undefined;
+        modelId?: string | undefined;
+        hyperdriveKey?: string | undefined;
+        hyperbeeKey?: string | undefined;
+        expectedSize?: number | undefined;
+        sha256Checksum?: string | undefined;
+        addon?: "llm" | "whisper" | "embeddings" | "nmt" | "vad" | "tts" | undefined;
+    };
+    seed?: boolean | undefined;
+}>>;
+export declare const downloadAssetOptionsToRequestSchema: z.ZodPipe<z.ZodObject<{
+    assetSrc: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        src: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+        modelId: z.ZodOptional<z.ZodString>;
+        hyperdriveKey: z.ZodOptional<z.ZodString>;
+        hyperbeeKey: z.ZodOptional<z.ZodString>;
+        expectedSize: z.ZodOptional<z.ZodNumber>;
+        sha256Checksum: z.ZodOptional<z.ZodString>;
+        addon: z.ZodOptional<z.ZodEnum<{
+            llm: "llm";
+            whisper: "whisper";
+            embeddings: "embeddings";
+            nmt: "nmt";
+            vad: "vad";
+            tts: "tts";
+        }>>;
+    }, z.core.$strip>]>;
+    seed: z.ZodOptional<z.ZodBoolean>;
+    onProgress: z.ZodOptional<z.ZodUnknown>;
+    withProgress: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>, z.ZodTransform<{
+    type: "downloadAsset";
     assetSrc: string;
+    withProgress: boolean;
+    seed: boolean;
+}, {
+    assetSrc: string | {
+        src: string;
+        name?: string | undefined;
+        modelId?: string | undefined;
+        hyperdriveKey?: string | undefined;
+        hyperbeeKey?: string | undefined;
+        expectedSize?: number | undefined;
+        sha256Checksum?: string | undefined;
+        addon?: "llm" | "whisper" | "embeddings" | "nmt" | "vad" | "tts" | undefined;
+    };
     seed?: boolean | undefined;
+    onProgress?: unknown;
+    withProgress?: boolean | undefined;
 }>>;
 export declare const downloadAssetRequestSchema: z.ZodPipe<z.ZodObject<{
     type: z.ZodLiteral<"downloadAsset">;

package/dist/schemas/download-asset.js

@@ -1,11 +1,22 @@
 import { z } from "zod";
-export const downloadAssetOptionsSchema = z
-    .object({
-    assetSrc: z.string(),
+import { modelSrcInputSchema, modelInputToSrcSchema } from "./model-src-utils.js";
+const downloadAssetOptionsBaseSchema = z.object({
+    assetSrc: modelSrcInputSchema,
     seed: z.boolean().optional(),
+});
+export const downloadAssetOptionsSchema = downloadAssetOptionsBaseSchema.transform((data) => ({
+    ...data,
+    seed: data.seed ?? false,
+}));
+export const downloadAssetOptionsToRequestSchema = downloadAssetOptionsBaseSchema
+    .extend({
+    onProgress: z.unknown().optional(),
+    withProgress: z.boolean().optional(),
 })
     .transform((data) => ({
-    ...data,
+    type: "downloadAsset",
+    assetSrc: modelInputToSrcSchema.parse(data.assetSrc),
+    withProgress: data.withProgress ?? !!data.onProgress,
     seed: data.seed ?? false,
 }));
 export const downloadAssetRequestSchema = z

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

@@ -0,0 +1,100 @@
+import { z } from "zod";
+export declare const getModelInfoParamsSchema: z.ZodObject<{
+    name: z.ZodString;
+}, z.core.$strip>;
+export declare const getModelInfoRequestSchema: z.ZodObject<{
+    name: z.ZodString;
+    type: z.ZodLiteral<"getModelInfo">;
+}, z.core.$strip>;
+export declare const loadedInstanceSchema: z.ZodObject<{
+    registryId: z.ZodString;
+    loadedAt: z.ZodCoercedDate<unknown>;
+    config: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strip>;
+export declare const cacheFileInfoSchema: z.ZodObject<{
+    filename: z.ZodString;
+    path: z.ZodString;
+    expectedSize: z.ZodNumber;
+    sha256Checksum: z.ZodString;
+    isCached: z.ZodBoolean;
+    actualSize: z.ZodOptional<z.ZodNumber>;
+    cachedAt: z.ZodOptional<z.ZodCoercedDate<unknown>>;
+}, z.core.$strip>;
+export declare const modelInfoSchema: z.ZodObject<{
+    name: z.ZodString;
+    modelId: z.ZodString;
+    hyperdriveKey: z.ZodString;
+    hyperbeeKey: z.ZodString;
+    expectedSize: z.ZodNumber;
+    sha256Checksum: z.ZodString;
+    addon: z.ZodEnum<{
+        llm: "llm";
+        whisper: "whisper";
+        embeddings: "embeddings";
+        nmt: "nmt";
+        vad: "vad";
+        tts: "tts";
+    }>;
+    isCached: z.ZodBoolean;
+    isLoaded: z.ZodBoolean;
+    cacheFiles: z.ZodArray<z.ZodObject<{
+        filename: z.ZodString;
+        path: z.ZodString;
+        expectedSize: z.ZodNumber;
+        sha256Checksum: z.ZodString;
+        isCached: z.ZodBoolean;
+        actualSize: z.ZodOptional<z.ZodNumber>;
+        cachedAt: z.ZodOptional<z.ZodCoercedDate<unknown>>;
+    }, z.core.$strip>>;
+    actualSize: z.ZodOptional<z.ZodNumber>;
+    cachedAt: z.ZodOptional<z.ZodCoercedDate<unknown>>;
+    loadedInstances: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        registryId: z.ZodString;
+        loadedAt: z.ZodCoercedDate<unknown>;
+        config: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export declare const getModelInfoResponseSchema: z.ZodObject<{
+    type: z.ZodLiteral<"getModelInfo">;
+    modelInfo: z.ZodObject<{
+        name: z.ZodString;
+        modelId: z.ZodString;
+        hyperdriveKey: z.ZodString;
+        hyperbeeKey: z.ZodString;
+        expectedSize: z.ZodNumber;
+        sha256Checksum: z.ZodString;
+        addon: z.ZodEnum<{
+            llm: "llm";
+            whisper: "whisper";
+            embeddings: "embeddings";
+            nmt: "nmt";
+            vad: "vad";
+            tts: "tts";
+        }>;
+        isCached: z.ZodBoolean;
+        isLoaded: z.ZodBoolean;
+        cacheFiles: z.ZodArray<z.ZodObject<{
+            filename: z.ZodString;
+            path: z.ZodString;
+            expectedSize: z.ZodNumber;
+            sha256Checksum: z.ZodString;
+            isCached: z.ZodBoolean;
+            actualSize: z.ZodOptional<z.ZodNumber>;
+            cachedAt: z.ZodOptional<z.ZodCoercedDate<unknown>>;
+        }, z.core.$strip>>;
+        actualSize: z.ZodOptional<z.ZodNumber>;
+        cachedAt: z.ZodOptional<z.ZodCoercedDate<unknown>>;
+        loadedInstances: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            registryId: z.ZodString;
+            loadedAt: z.ZodCoercedDate<unknown>;
+            config: z.ZodOptional<z.ZodUnknown>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type GetModelInfoParams = z.input<typeof getModelInfoParamsSchema>;
+export type GetModelInfoRequest = z.infer<typeof getModelInfoRequestSchema>;
+export type LoadedInstance = z.infer<typeof loadedInstanceSchema>;
+export type CacheFileInfo = z.infer<typeof cacheFileInfoSchema>;
+export type ModelInfo = z.infer<typeof modelInfoSchema>;
+export type GetModelInfoResponse = z.infer<typeof getModelInfoResponseSchema>;
+//# sourceMappingURL=get-model-info.d.ts.map

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

@@ -0,0 +1,40 @@
+import { z } from "zod";
+export const getModelInfoParamsSchema = z.object({
+    name: z.string(),
+});
+export const getModelInfoRequestSchema = getModelInfoParamsSchema.extend({
+    type: z.literal("getModelInfo"),
+});
+export const loadedInstanceSchema = z.object({
+    registryId: z.string(),
+    loadedAt: z.coerce.date(),
+    config: z.unknown().optional(),
+});
+export const cacheFileInfoSchema = z.object({
+    filename: z.string(),
+    path: z.string(),
+    expectedSize: z.number(),
+    sha256Checksum: z.string(),
+    isCached: z.boolean(),
+    actualSize: z.number().optional(),
+    cachedAt: z.coerce.date().optional(),
+});
+export const modelInfoSchema = z.object({
+    name: z.string(),
+    modelId: z.string(),
+    hyperdriveKey: z.string(),
+    hyperbeeKey: z.string(),
+    expectedSize: z.number(),
+    sha256Checksum: z.string(),
+    addon: z.enum(["llm", "whisper", "embeddings", "nmt", "vad", "tts"]),
+    isCached: z.boolean(),
+    isLoaded: z.boolean(),
+    cacheFiles: z.array(cacheFileInfoSchema),
+    actualSize: z.number().optional(),
+    cachedAt: z.coerce.date().optional(),
+    loadedInstances: z.array(loadedInstanceSchema).optional(),
+});
+export const getModelInfoResponseSchema = z.object({
+    type: z.literal("getModelInfo"),
+    modelInfo: modelInfoSchema,
+});

package/dist/schemas/index.d.ts

@@ -1,5 +1,6 @@
 export * from "./cancel";
 export * from "./completion-stream";
+export * from "./tools";
 export * from "./delegate";
 export * from "./delete-cache";
 export * from "./download-asset";
@@ -16,6 +17,12 @@ export * from "./translate";
 export * from "./translation-config";
 export * from "./llamacpp-config";
 export * from "./whispercpp-config";
+export * from "./text-to-speech";
 export * from "./error";
 export * from "./rag";
+export { SDK_CLIENT_ERROR_CODES } from "./sdk-errors-client";
+export { SDK_SERVER_ERROR_CODES } from "./sdk-errors-server";
+export * from "./set-config";
+export * from "./get-model-info";
+export * from "./model-src-utils";
 //# sourceMappingURL=index.d.ts.map

package/dist/schemas/index.js

@@ -1,6 +1,7 @@
 // Re-export all schemas and types
 export * from "./cancel.js";
 export * from "./completion-stream.js";
+export * from "./tools.js";
 export * from "./delegate.js";
 export * from "./delete-cache.js";
 export * from "./download-asset.js";
@@ -17,5 +18,11 @@ export * from "./translate.js";
 export * from "./translation-config.js";
 export * from "./llamacpp-config.js";
 export * from "./whispercpp-config.js";
+export * from "./text-to-speech.js";
 export * from "./error.js";
 export * from "./rag.js";
+export { SDK_CLIENT_ERROR_CODES } from "./sdk-errors-client.js";
+export { SDK_SERVER_ERROR_CODES } from "./sdk-errors-server.js";
+export * from "./set-config.js";
+export * from "./get-model-info.js";
+export * from "./model-src-utils.js";

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

@@ -20,8 +20,9 @@ export declare const llmConfigSchema: z.ZodObject<{
     presence_penalty: z.ZodOptional<z.ZodNumber>;
     frequency_penalty: z.ZodOptional<z.ZodNumber>;
     repeat_penalty: z.ZodOptional<z.ZodNumber>;
-    reverse_prompt: z.ZodOptional<z.ZodString>;
+    stop_sequences: z.ZodOptional<z.ZodArray<z.ZodString>>;
     n_discarded: z.ZodOptional<z.ZodNumber>;
+    tools: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
 export declare const embedConfigSchema: z.ZodObject<{
     config: z.ZodDefault<z.ZodString>;

package/dist/schemas/llamacpp-config.js

@@ -31,12 +31,11 @@ export const llmConfigSchema = z.object({
     presence_penalty: z.number().optional(),
     frequency_penalty: z.number().optional(),
     repeat_penalty: z.number().optional(),
-    reverse_prompt: z.string().optional(),
+    stop_sequences: z.array(z.string()).optional(),
     n_discarded: z.number().optional(),
+    tools: z.boolean().optional(),
 });
 export const embedConfigSchema = z.object({
     // https://github.com/tetherto/qvac-lib-infer-llamacpp-embed/tree/main?tab=readme-ov-file#4-create-config
-    config: z
-        .string()
-        .default("-ngl\t99\n-dev\tgpu\n--embd-separator\t⟪§§§EMBED_SEP§§§⟫\n-c\t512"),
+    config: z.string().default("-ngl\t99\n-dev\tgpu"),
 });