@qvac/sdk 0.5.0 → 0.6.0

package/dist/schemas/rag.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-// ============== Common Types ==============
+// ============== Common Schemas ==============
 const llmChunkOptsSchema = z.object({
     chunkSize: z.number().optional(),
     chunkOverlap: z.number().optional(),
@@ -8,63 +8,154 @@ const llmChunkOptsSchema = z.object({
         .enum(["character", "word", "token", "sentence", "line"])
         .optional(),
 });
-const ragSaveEmbeddingsResultSchema = z.object({
+const saveEmbeddingsResultSchema = z.object({
     status: z.enum(["fulfilled", "rejected"]),
     id: z.string().optional(),
     error: z.string().optional(),
 });
-const searchResultSchema = z.object({
-    id: z.string(),
-    content: z.string(),
-    score: z.number(),
+// ============== 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: z.string().optional(),
 });
-// ============== Request Schema ==============
-const ragBaseSchema = z.object({
+// For operations that need the embedding model (ingest, search)
+const ragBaseSchema = ragStorageOnlyBaseSchema.extend({
     modelId: z.string(),
-    workspace: z.string().optional(), // Optional workspace for isolated storage
 });
-const ragSaveEmbeddingsParamsSchema = ragBaseSchema.extend({
+// ============== Ingest Operation ==============
+export const ragIngestParamsSchema = ragBaseSchema.extend({
     documents: z.union([z.string(), z.array(z.string())]),
-    chunk: z.boolean().default(false),
+    chunk: z.boolean().default(true),
     chunkOpts: llmChunkOptsSchema.optional(),
+    progressInterval: z.number().positive().optional(),
+    onProgress: z.unknown().optional(),
+    withProgress: z.boolean().optional(),
 });
-export const ragSaveEmbeddingsOperationSchema = ragSaveEmbeddingsParamsSchema.extend({
+const ragIngestOperationSchema = ragIngestParamsSchema.extend({
+    type: z.literal("rag"),
+    operation: z.literal("ingest"),
+});
+// ============== Chunk Operation ==============
+const docSchema = z.object({
+    id: z.string(),
+    content: z.string(),
+});
+export const ragChunkParamsSchema = z.object({
+    documents: z.union([z.string(), z.array(z.string())]),
+    chunkOpts: llmChunkOptsSchema.optional(),
+});
+const ragChunkOperationSchema = ragChunkParamsSchema.extend({
+    type: z.literal("rag"),
+    operation: z.literal("chunk"),
+});
+// ============== SaveEmbeddings Operation ==============
+const embeddedDocSchema = z.object({
+    id: z.string(),
+    content: z.string(),
+    embedding: z.array(z.number()),
+    embeddingModelId: z.string(),
+    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(),
+});
+const ragSaveEmbeddingsOperationSchema = ragSaveEmbeddingsParamsSchema.extend({
     type: z.literal("rag"),
     operation: z.literal("saveEmbeddings"),
 });
-const ragSearchParamsSchema = ragBaseSchema.extend({
-    query: z.string().min(1, "Query cannot be empty"),
-    topK: z.number().positive().optional(),
-    n: z.number().positive().optional(),
+// ============== Reindex Operation ==============
+const reindexResultSchema = z.object({
+    reindexed: z.boolean(),
+    details: z.record(z.string(), z.unknown()).optional(),
 });
-export const ragSearchOperationSchema = ragSearchParamsSchema.extend({
+export const ragReindexParamsSchema = ragStorageOnlyBaseSchema.extend({
+    onProgress: z.unknown().optional(),
+    withProgress: z.boolean().optional(),
+});
+const ragReindexOperationSchema = ragReindexParamsSchema.extend({
     type: z.literal("rag"),
-    operation: z.literal("search"),
+    operation: z.literal("reindex"),
+});
+// ============== Search Operation ==============
+const searchResultSchema = z.object({
+    id: z.string(),
+    content: z.string(),
+    score: z.number(),
+});
+export const ragSearchParamsSchema = ragBaseSchema.extend({
+    query: z.string().min(1, "Query cannot be empty"),
     topK: z.number().positive().default(5),
     n: z.number().positive().default(3),
 });
-const deleteEmbeddingsParamsSchema = ragBaseSchema.extend({
+const ragSearchOperationSchema = ragSearchParamsSchema.extend({
+    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"),
 });
-export const ragDeleteEmbeddingsOperationSchema = deleteEmbeddingsParamsSchema.extend({
+const ragDeleteEmbeddingsOperationSchema = ragDeleteEmbeddingsParamsSchema.extend({
     type: z.literal("rag"),
     operation: z.literal("deleteEmbeddings"),
 });
+// ============== List Workspaces Operation ==============
+const ragListWorkspacesOperationSchema = z.object({
+    type: z.literal("rag"),
+    operation: z.literal("listWorkspaces"),
+});
+// ============== Close Workspace Operation ==============
+export const ragCloseWorkspaceParamsSchema = z.object({
+    workspace: z.string().optional(),
+    deleteOnClose: z.boolean().optional(),
+});
+const ragCloseWorkspaceOperationSchema = ragCloseWorkspaceParamsSchema.extend({
+    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"),
+});
+const ragDeleteWorkspaceOperationSchema = ragDeleteWorkspaceParamsSchema.extend({
+    type: z.literal("rag"),
+    operation: z.literal("deleteWorkspace"),
+});
+// ============== Unified Request Schema ==============
 export const ragRequestSchema = z.discriminatedUnion("operation", [
+    ragChunkOperationSchema,
+    ragIngestOperationSchema,
     ragSaveEmbeddingsOperationSchema,
     ragSearchOperationSchema,
     ragDeleteEmbeddingsOperationSchema,
+    ragReindexOperationSchema,
+    ragListWorkspacesOperationSchema,
+    ragCloseWorkspaceOperationSchema,
+    ragDeleteWorkspaceOperationSchema,
 ]);
-// ============== Response Schema ==============
+// ============== Response Schemas ==============
 const ragResponseBaseSchema = z.object({
     type: z.literal("rag"),
     success: z.boolean(),
     error: z.string().optional(),
 });
+const ragChunkResponseSchema = ragResponseBaseSchema.extend({
+    operation: z.literal("chunk"),
+    chunks: z.array(docSchema),
+});
+const ragIngestResponseSchema = ragResponseBaseSchema.extend({
+    operation: z.literal("ingest"),
+    processed: z.array(saveEmbeddingsResultSchema),
+    droppedIndices: z.array(z.number()),
+});
 const ragSaveEmbeddingsResponseSchema = ragResponseBaseSchema.extend({
     operation: z.literal("saveEmbeddings"),
-    processed: z.array(ragSaveEmbeddingsResultSchema),
-    droppedIndices: z.array(z.number()),
+    processed: z.array(saveEmbeddingsResultSchema),
 });
 const ragSearchResponseSchema = ragResponseBaseSchema.extend({
     operation: z.literal("search"),
@@ -73,8 +164,42 @@ const ragSearchResponseSchema = ragResponseBaseSchema.extend({
 const ragDeleteEmbeddingsResponseSchema = ragResponseBaseSchema.extend({
     operation: z.literal("deleteEmbeddings"),
 });
+const ragReindexResponseSchema = ragResponseBaseSchema.extend({
+    operation: z.literal("reindex"),
+    result: reindexResultSchema,
+});
+const ragWorkspaceInfoSchema = z.object({
+    name: z.string(),
+    open: z.boolean(),
+});
+const ragListWorkspacesResponseSchema = ragResponseBaseSchema.extend({
+    operation: z.literal("listWorkspaces"),
+    workspaces: z.array(ragWorkspaceInfoSchema),
+});
+const ragCloseWorkspaceResponseSchema = ragResponseBaseSchema.extend({
+    operation: z.literal("closeWorkspace"),
+});
+const ragDeleteWorkspaceResponseSchema = ragResponseBaseSchema.extend({
+    operation: z.literal("deleteWorkspace"),
+});
 export const ragResponseSchema = z.discriminatedUnion("operation", [
+    ragChunkResponseSchema,
+    ragIngestResponseSchema,
     ragSaveEmbeddingsResponseSchema,
     ragSearchResponseSchema,
     ragDeleteEmbeddingsResponseSchema,
+    ragReindexResponseSchema,
+    ragListWorkspacesResponseSchema,
+    ragCloseWorkspaceResponseSchema,
+    ragDeleteWorkspaceResponseSchema,
 ]);
+// ============== Progress Update Schema ==============
+export const ragProgressUpdateSchema = z.object({
+    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(),
+});

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

@@ -3,7 +3,10 @@ import { whisperConfigSchema } from "./whispercpp-config";
 export declare const modelIdSchema: z.ZodString;
 export declare const reloadConfigOptionsSchema: z.ZodUnion<readonly [z.ZodObject<{
     modelId: z.ZodString;
-    modelType: z.ZodLiteral<"whisper">;
+    modelType: z.ZodEnum<{
+        "whispercpp-transcription": "whispercpp-transcription";
+        whisper: "whisper";
+    }>;
     modelConfig: z.ZodObject<{
         strategy: z.ZodOptional<z.ZodOptional<z.ZodEnum<{
             greedy: "greedy";
@@ -69,7 +72,10 @@ export declare const reloadConfigOptionsSchema: z.ZodUnion<readonly [z.ZodObject
 }, z.core.$strip>]>;
 export declare const reloadConfigOptionsToRequestSchema: z.ZodUnion<readonly [z.ZodPipe<z.ZodObject<{
     modelId: z.ZodString;
-    modelType: z.ZodLiteral<"whisper">;
+    modelType: z.ZodEnum<{
+        "whispercpp-transcription": "whispercpp-transcription";
+        whisper: "whisper";
+    }>;
     modelConfig: z.ZodObject<{
         strategy: z.ZodOptional<z.ZodOptional<z.ZodEnum<{
             greedy: "greedy";
@@ -135,11 +141,11 @@ export declare const reloadConfigOptionsToRequestSchema: z.ZodUnion<readonly [z.
 }, z.core.$strip>, z.ZodTransform<{
     type: "loadModel";
     modelId: string;
-    modelType: "whisper";
+    modelType: "whispercpp-transcription" | "whisper";
     modelConfig: z.infer<typeof whisperConfigSchema>;
 }, {
     modelId: string;
-    modelType: "whisper";
+    modelType: "whispercpp-transcription" | "whisper";
     modelConfig: {
         strategy?: "greedy" | "beam_search" | undefined;
         n_threads?: number | undefined;
@@ -204,7 +210,10 @@ export declare const reloadConfigWhisperRequestSchema: z.ZodObject<{
     withProgress: z.ZodOptional<z.ZodNever>;
     delegate: z.ZodOptional<z.ZodNever>;
     seed: z.ZodOptional<z.ZodNever>;
-    modelType: z.ZodLiteral<"whisper">;
+    modelType: z.ZodEnum<{
+        "whispercpp-transcription": "whispercpp-transcription";
+        whisper: "whisper";
+    }>;
     modelConfig: z.ZodObject<{
         strategy: z.ZodOptional<z.ZodOptional<z.ZodEnum<{
             greedy: "greedy";
@@ -268,14 +277,17 @@ export declare const reloadConfigWhisperRequestSchema: z.ZodObject<{
         }, z.core.$strip>>>;
     }, z.core.$strip>;
 }, z.core.$strip>;
-export declare const reloadConfigRequestSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+export declare const reloadConfigRequestSchema: z.ZodUnion<readonly [z.ZodObject<{
     type: z.ZodLiteral<"loadModel">;
     modelId: z.ZodString;
     modelSrc: z.ZodOptional<z.ZodNever>;
     withProgress: z.ZodOptional<z.ZodNever>;
     delegate: z.ZodOptional<z.ZodNever>;
     seed: z.ZodOptional<z.ZodNever>;
-    modelType: z.ZodLiteral<"whisper">;
+    modelType: z.ZodEnum<{
+        "whispercpp-transcription": "whispercpp-transcription";
+        whisper: "whisper";
+    }>;
     modelConfig: z.ZodObject<{
         strategy: z.ZodOptional<z.ZodOptional<z.ZodEnum<{
             greedy: "greedy";
@@ -338,7 +350,7 @@ export declare const reloadConfigRequestSchema: z.ZodDiscriminatedUnion<[z.ZodOb
             caption_enabled: z.ZodOptional<z.ZodBoolean>;
         }, z.core.$strip>>>;
     }, z.core.$strip>;
-}, z.core.$strip>], "modelType">;
+}, z.core.$strip>]>;
 export type ReloadConfigRequest = z.infer<typeof reloadConfigRequestSchema>;
 export type ReloadConfigOptions = z.infer<typeof reloadConfigOptionsSchema>;
 //# sourceMappingURL=reload-config.d.ts.map

package/dist/schemas/reload-config.js

@@ -1,12 +1,13 @@
 import { z } from "zod";
 import { whisperConfigSchema } from "./whispercpp-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: z.literal("whisper"),
+        modelType: whisperModelTypeSchema,
         modelConfig: whisperConfigSchema.partial().strict(),
     }),
 ]);
@@ -14,13 +15,13 @@ export const reloadConfigOptionsToRequestSchema = z.union([
     z
         .object({
         modelId: modelIdSchema,
-        modelType: z.literal("whisper"),
+        modelType: whisperModelTypeSchema,
         modelConfig: whisperConfigSchema.partial().strict(),
     })
         .transform((data) => ({
         type: "loadModel",
         modelId: data.modelId,
-        modelType: "whisper",
+        modelType: data.modelType,
         modelConfig: data.modelConfig,
     })),
 ]);
@@ -34,9 +35,10 @@ const reloadConfigRequestBaseSchema = z.object({
     seed: z.never().optional(),
 });
 export const reloadConfigWhisperRequestSchema = reloadConfigRequestBaseSchema.extend({
-    modelType: z.literal("whisper"),
+    modelType: whisperModelTypeSchema,
     modelConfig: whisperConfigSchema.partial(),
 });
-export const reloadConfigRequestSchema = z.discriminatedUnion("modelType", [
+// Using z.union since modelType accepts multiple values
+export const reloadConfigRequestSchema = z.union([
     reloadConfigWhisperRequestSchema,
 ]);

package/dist/schemas/runtime-context.d.ts

@@ -0,0 +1,19 @@
+import { z } from "zod";
+export declare const runtimeContextSchema: z.ZodObject<{
+    runtime: z.ZodOptional<z.ZodEnum<{
+        node: "node";
+        bare: "bare";
+        "react-native": "react-native";
+    }>>;
+    platform: z.ZodOptional<z.ZodEnum<{
+        android: "android";
+        ios: "ios";
+        darwin: "darwin";
+        linux: "linux";
+        win32: "win32";
+    }>>;
+    deviceModel: z.ZodOptional<z.ZodString>;
+    deviceBrand: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type RuntimeContext = z.infer<typeof runtimeContextSchema>;
+//# sourceMappingURL=runtime-context.d.ts.map

package/dist/schemas/runtime-context.js

@@ -0,0 +1,7 @@
+import { z } from "zod";
+export const runtimeContextSchema = z.object({
+    runtime: z.enum(["node", "bare", "react-native"]).optional(),
+    platform: z.enum(["android", "ios", "darwin", "linux", "win32"]).optional(),
+    deviceModel: z.string().optional(),
+    deviceBrand: z.string().optional(),
+});