@qvac/sdk 0.1.0-dev.1760648187.328e967

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

@@ -0,0 +1,125 @@
+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>;
+export declare const completionParamsSchema: z.ZodObject<{
+    history: z.ZodArray<z.ZodObject<{
+        role: z.ZodString;
+        content: z.ZodString;
+        attachments: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    modelId: z.ZodString;
+    kvCache: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const completionClientParamsSchema: z.ZodObject<{
+    history: z.ZodArray<z.ZodObject<{
+        role: z.ZodString;
+        content: z.ZodString;
+        attachments: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    modelId: z.ZodString;
+    tools: z.ZodOptional<z.ZodArray<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>>>;
+    stream: z.ZodBoolean;
+    kvCache: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const completionStreamRequestSchema: z.ZodObject<{
+    history: z.ZodArray<z.ZodObject<{
+        role: z.ZodString;
+        content: z.ZodString;
+        attachments: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    modelId: z.ZodString;
+    tools: z.ZodOptional<z.ZodArray<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>>>;
+    stream: z.ZodBoolean;
+    kvCache: z.ZodOptional<z.ZodBoolean>;
+    type: z.ZodLiteral<"completionStream">;
+}, z.core.$strip>;
+export declare const completionStatsSchema: z.ZodObject<{
+    timeToFirstToken: z.ZodNumber;
+    tokensPerSecond: z.ZodNumber;
+}, z.core.$strip>;
+export declare const completionStreamResponseSchema: z.ZodObject<{
+    type: z.ZodLiteral<"completionStream">;
+    token: z.ZodString;
+    done: z.ZodOptional<z.ZodBoolean>;
+    stats: z.ZodOptional<z.ZodObject<{
+        timeToFirstToken: z.ZodNumber;
+        tokensPerSecond: z.ZodNumber;
+    }, z.core.$strip>>;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type CompletionParams = z.infer<typeof completionParamsSchema>;
+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

@@ -0,0 +1,53 @@
+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(),
+    }),
+});
+export const attachmentSchema = z.object({
+    path: z.string(),
+});
+export const completionParamsSchema = z.object({
+    history: z.array(z.object({
+        role: z.string(),
+        content: z.string(),
+        attachments: z.array(attachmentSchema).optional(),
+    })),
+    modelId: z.string(),
+    kvCache: z.boolean().optional(),
+});
+export const completionClientParamsSchema = completionParamsSchema.extend({
+    tools: z.array(toolSchema).optional(),
+    stream: z.boolean(),
+    kvCache: z.boolean().optional(),
+});
+export const completionStreamRequestSchema = completionClientParamsSchema.extend({
+    type: z.literal("completionStream"),
+});
+export const completionStatsSchema = z.object({
+    timeToFirstToken: z.number(),
+    tokensPerSecond: z.number(),
+});
+export const completionStreamResponseSchema = z.object({
+    type: z.literal("completionStream"),
+    token: z.string(),
+    done: z.boolean().optional(),
+    stats: completionStatsSchema.optional(),
+    error: z.string().optional(),
+});

package/dist/schemas/delegate.d.ts

@@ -0,0 +1,9 @@
+import { z } from "zod";
+export declare const delegateSchema: z.ZodOptional<z.ZodObject<{
+    topic: z.ZodString;
+    providerPublicKey: z.ZodString;
+    timeout: z.ZodOptional<z.ZodNumber>;
+    fallbackToLocal: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, z.core.$strip>>;
+export type Delegate = z.infer<typeof delegateSchema>;
+//# sourceMappingURL=delegate.d.ts.map

package/dist/schemas/delegate.js

@@ -0,0 +1,9 @@
+import { z } from "zod";
+export const delegateSchema = z
+    .object({
+    topic: z.string(),
+    providerPublicKey: z.string(),
+    timeout: z.number().min(100).optional(),
+    fallbackToLocal: z.boolean().optional().default(false),
+})
+    .optional();

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

@@ -0,0 +1,75 @@
+import { z } from "zod";
+import type { ModelProgressUpdate } from "./load-model";
+export declare const downloadAssetOptionsSchema: z.ZodPipe<z.ZodObject<{
+    assetSrc: z.ZodString;
+    seed: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>, z.ZodTransform<{
+    seed: boolean;
+    assetSrc: string;
+}, {
+    assetSrc: string;
+    seed?: boolean | undefined;
+}>>;
+export declare const downloadAssetRequestSchema: z.ZodPipe<z.ZodObject<{
+    type: z.ZodLiteral<"downloadAsset">;
+    assetSrc: z.ZodString;
+    withProgress: z.ZodOptional<z.ZodBoolean>;
+    seed: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>, z.ZodTransform<{
+    seed: boolean;
+    type: "downloadAsset";
+    assetSrc: string;
+    withProgress?: boolean | undefined;
+}, {
+    type: "downloadAsset";
+    assetSrc: string;
+    withProgress?: boolean | undefined;
+    seed?: boolean | undefined;
+}>>;
+export declare const downloadAssetResponseSchema: z.ZodObject<{
+    type: z.ZodLiteral<"downloadAsset">;
+    success: z.ZodBoolean;
+    assetId: z.ZodOptional<z.ZodString>;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const downloadTypeSchema: z.ZodEnum<{
+    hyperdrive: "hyperdrive";
+    http: "http";
+}>;
+export declare const downloadMetadataSchema: z.ZodObject<{
+    key: z.ZodString;
+    startTime: z.ZodNumber;
+    type: z.ZodEnum<{
+        hyperdrive: "hyperdrive";
+        http: "http";
+    }>;
+}, z.core.$strip>;
+export declare const hyperdriveDownloadMetadataSchema: z.ZodObject<{
+    key: z.ZodString;
+    startTime: z.ZodNumber;
+    type: z.ZodLiteral<"hyperdrive">;
+    hyperdriveKey: z.ZodString;
+    modelFileName: z.ZodString;
+}, z.core.$strip>;
+export declare const httpDownloadMetadataSchema: z.ZodObject<{
+    key: z.ZodString;
+    startTime: z.ZodNumber;
+    type: z.ZodLiteral<"http">;
+    url: z.ZodURL;
+    modelPath: z.ZodString;
+}, z.core.$strip>;
+export type DownloadAssetOptions = z.input<typeof downloadAssetOptionsSchema> & {
+    onProgress?: (progress: ModelProgressUpdate) => void;
+};
+export type DownloadAssetRequest = z.infer<typeof downloadAssetRequestSchema>;
+export type DownloadAssetResponse = z.infer<typeof downloadAssetResponseSchema>;
+export type DownloadType = z.infer<typeof downloadTypeSchema>;
+export type BaseDownloadEntry = z.infer<typeof downloadMetadataSchema> & {
+    promise: Promise<string>;
+    abortController: AbortController;
+    onProgress?: (progress: ModelProgressUpdate) => void;
+};
+export type HyperdriveDownloadEntry = BaseDownloadEntry & z.infer<typeof hyperdriveDownloadMetadataSchema>;
+export type HttpDownloadEntry = BaseDownloadEntry & z.infer<typeof httpDownloadMetadataSchema>;
+export type DownloadEntry = HyperdriveDownloadEntry | HttpDownloadEntry;
+//# sourceMappingURL=download-asset.d.ts.map

package/dist/schemas/download-asset.js

@@ -0,0 +1,43 @@
+import { z } from "zod";
+export const downloadAssetOptionsSchema = z
+    .object({
+    assetSrc: z.string(),
+    seed: z.boolean().optional(),
+})
+    .transform((data) => ({
+    ...data,
+    seed: data.seed ?? false,
+}));
+export const downloadAssetRequestSchema = z
+    .object({
+    type: z.literal("downloadAsset"),
+    assetSrc: z.string(),
+    withProgress: z.boolean().optional(),
+    seed: z.boolean().optional(),
+})
+    .transform((data) => ({
+    ...data,
+    seed: data.seed ?? false,
+}));
+export const downloadAssetResponseSchema = z.object({
+    type: z.literal("downloadAsset"),
+    success: z.boolean(),
+    assetId: z.string().optional(),
+    error: z.string().optional(),
+});
+export const downloadTypeSchema = z.enum(["hyperdrive", "http"]);
+export const downloadMetadataSchema = z.object({
+    key: z.string(),
+    startTime: z.number(),
+    type: downloadTypeSchema,
+});
+export const hyperdriveDownloadMetadataSchema = downloadMetadataSchema.extend({
+    type: z.literal("hyperdrive"),
+    hyperdriveKey: z.string(),
+    modelFileName: z.string(),
+});
+export const httpDownloadMetadataSchema = downloadMetadataSchema.extend({
+    type: z.literal("http"),
+    url: z.url(),
+    modelPath: z.string(),
+});

package/dist/schemas/embed.d.ts

@@ -0,0 +1,20 @@
+import { z } from "zod";
+export declare const embedParamsSchema: z.ZodObject<{
+    modelId: z.ZodString;
+    text: z.ZodString;
+}, z.core.$strip>;
+export declare const embedRequestSchema: z.ZodObject<{
+    modelId: z.ZodString;
+    text: z.ZodString;
+    type: z.ZodLiteral<"embed">;
+}, z.core.$strip>;
+export declare const embedResponseSchema: z.ZodObject<{
+    type: z.ZodLiteral<"embed">;
+    success: z.ZodBoolean;
+    embedding: z.ZodDefault<z.ZodArray<z.ZodNumber>>;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type EmbedParams = z.infer<typeof embedParamsSchema>;
+export type EmbedRequest = z.infer<typeof embedRequestSchema>;
+export type EmbedResponse = z.infer<typeof embedResponseSchema>;
+//# sourceMappingURL=embed.d.ts.map

package/dist/schemas/embed.js

@@ -0,0 +1,14 @@
+import { z } from "zod";
+export const embedParamsSchema = z.object({
+    modelId: z.string(),
+    text: z.string().min(1, "Text cannot be empty"),
+});
+export const embedRequestSchema = embedParamsSchema.extend({
+    type: z.literal("embed"),
+});
+export const embedResponseSchema = z.object({
+    type: z.literal("embed"),
+    success: z.boolean(),
+    embedding: z.array(z.number()).default([]),
+    error: z.string().optional(),
+});

package/dist/schemas/error.d.ts

@@ -0,0 +1,13 @@
+import { z } from "zod";
+export declare const errorResponseSchema: z.ZodObject<{
+    type: z.ZodLiteral<"error">;
+    message: z.ZodString;
+    stack: z.ZodOptional<z.ZodString>;
+    timestamp: z.ZodOptional<z.ZodString>;
+    name: z.ZodOptional<z.ZodString>;
+    code: z.ZodOptional<z.ZodNumber>;
+    cause: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strip>;
+export type ErrorResponse = z.infer<typeof errorResponseSchema>;
+export declare function createErrorResponse(error: unknown): ErrorResponse;
+//# sourceMappingURL=error.d.ts.map

package/dist/schemas/error.js

@@ -0,0 +1,35 @@
+import { z } from "zod";
+import { QvacErrorBase } from "@qvac/error";
+export const errorResponseSchema = z.object({
+    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(),
+});
+function isQvacError(error) {
+    return error instanceof QvacErrorBase;
+}
+export function createErrorResponse(error) {
+    if (isQvacError(error)) {
+        const qvacData = error.toJSON();
+        return {
+            type: "error",
+            name: qvacData.name,
+            code: qvacData.code,
+            message: qvacData.message,
+            stack: qvacData.stack,
+            timestamp: new Date().toISOString(),
+        };
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    const stack = error instanceof Error ? error.stack : undefined;
+    return {
+        type: "error",
+        message,
+        stack,
+        timestamp: new Date().toISOString(),
+    };
+}

package/dist/schemas/index.d.ts

@@ -0,0 +1,19 @@
+export * from "./cancel";
+export * from "./completion-stream";
+export * from "./delegate";
+export * from "./download-asset";
+export * from "./embed";
+export * from "./load-model";
+export * from "./logging-stream";
+export * from "./provide";
+export * from "./unload-model";
+export * from "./ping";
+export * from "./common";
+export * from "./transcription";
+export * from "./translate";
+export * from "./translation-config";
+export * from "./llamacpp-config";
+export * from "./whispercpp-config";
+export * from "./error";
+export * from "./rag";
+//# sourceMappingURL=index.d.ts.map

package/dist/schemas/index.js

@@ -0,0 +1,19 @@
+// Re-export all schemas and types
+export * from "./cancel.js";
+export * from "./completion-stream.js";
+export * from "./delegate.js";
+export * from "./download-asset.js";
+export * from "./embed.js";
+export * from "./load-model.js";
+export * from "./logging-stream.js";
+export * from "./provide.js";
+export * from "./unload-model.js";
+export * from "./ping.js";
+export * from "./common.js";
+export * from "./transcription.js";
+export * from "./translate.js";
+export * from "./translation-config.js";
+export * from "./llamacpp-config.js";
+export * from "./whispercpp-config.js";
+export * from "./error.js";
+export * from "./rag.js";

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

@@ -0,0 +1,30 @@
+import { z } from "zod";
+export declare const VERBOSITY: {
+    readonly SILENT: -1;
+    readonly INFO: 0;
+    readonly DEBUG: 1;
+};
+export declare const llmConfigSchema: z.ZodObject<{
+    ctx_size: z.ZodDefault<z.ZodNumber>;
+    temp: z.ZodOptional<z.ZodNumber>;
+    top_p: z.ZodOptional<z.ZodNumber>;
+    top_k: z.ZodOptional<z.ZodNumber>;
+    seed: z.ZodOptional<z.ZodNumber>;
+    gpu_layers: z.ZodDefault<z.ZodNumber>;
+    lora: z.ZodOptional<z.ZodString>;
+    device: z.ZodDefault<z.ZodString>;
+    predict: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<-1>, z.ZodLiteral<-2>, z.ZodNumber]>>;
+    system_prompt: z.ZodOptional<z.ZodString>;
+    no_mmap: z.ZodOptional<z.ZodBoolean>;
+    verbosity: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<-1>, z.ZodLiteral<0>, z.ZodLiteral<1>]>>;
+    presence_penalty: z.ZodOptional<z.ZodNumber>;
+    frequency_penalty: z.ZodOptional<z.ZodNumber>;
+    repeat_penalty: z.ZodOptional<z.ZodNumber>;
+    reverse_prompt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const embedConfigSchema: z.ZodObject<{
+    config: z.ZodDefault<z.ZodString>;
+}, z.core.$strip>;
+export type LlmConfig = z.infer<typeof llmConfigSchema>;
+export type EmbedConfig = z.infer<typeof embedConfigSchema>;
+//# sourceMappingURL=llamacpp-config.d.ts.map

package/dist/schemas/llamacpp-config.js

@@ -0,0 +1,39 @@
+import { z } from "zod";
+export const VERBOSITY = {
+    SILENT: -1,
+    INFO: 0,
+    DEBUG: 1,
+};
+const verbositySchema = z.union([
+    z.literal(VERBOSITY.SILENT),
+    z.literal(VERBOSITY.INFO),
+    z.literal(VERBOSITY.DEBUG),
+]);
+export const llmConfigSchema = z.object({
+    ctx_size: z.number().default(1024),
+    temp: z.number().min(0).max(2).optional(),
+    top_p: z.number().min(0).max(1).optional(),
+    top_k: z.number().int().min(0).max(128).optional(),
+    seed: z.number().optional(),
+    gpu_layers: z.number().default(99),
+    lora: z.string().optional(),
+    device: z.string().default("gpu"),
+    predict: z
+        .union([
+        z.literal(-1), // special: until stop token
+        z.literal(-2), // special: until context filled
+        z.number().int().min(1), // positive integer: fixed token count
+    ])
+        .optional(),
+    system_prompt: z.string().optional(),
+    no_mmap: z.boolean().optional(),
+    verbosity: verbositySchema.optional(),
+    presence_penalty: z.number().optional(),
+    frequency_penalty: z.number().optional(),
+    repeat_penalty: z.number().optional(),
+    reverse_prompt: z.string().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\t25"),
+});