@qvac/sdk 0.1.1 → 0.2.0-dev.1760804157.f3c48d2

package/README.md

@@ -79,7 +79,7 @@ npm i expo-file-system react-native-bare-kit
 ```js
 export default {
   expo: {
-    plugins: ["@qvac/sdk/expo-plugin"],
+    plugins: ["qvac-sdk/expo-plugin"],
   },
 };
 ```
@@ -141,7 +141,6 @@ const cachedResponse = completion({
 
 // Unload model to free up system resources
 await unloadModel({ modelId });
-process.exit();
 ```
 
 **For more on how to use QVAC SDK, see [SDK at QVAC documentation](https://tether-2.gitbook.io/qvac-by-tether-or-reference/y2AsIh94H9DJ1pIBCNj9/sdk)**.
@@ -162,10 +161,10 @@ bun run build  # or `watch` for hotreload
 bun run build:pack
 ```
 
-This outputs a tarball under `dist/qvac-sdk-{version}.tgz` that you can install in your project, e.g.:
+This outputs a tarball under `dist/tetherto-qvac-sdk-{version}.tgz` that you can install in your project, e.g.:
 
 ```bash
-npm i path/to/qvac-sdk-0.1.0.tgz
+npm i path/to/tetherto-qvac-sdk-0.0.1.tgz
 ```
 
 ## Examples

package/dist/client/api/completion-stream.d.ts

@@ -7,25 +7,40 @@ import { type CompletionStats, type CompletionClientParams } from "../../schemas
  * @param params.history - Array of conversation messages with role, content, and optional attachments
  * @param params.stream - Whether to stream tokens (true) or return complete response (false). Defaults to true
  * @param params.tools - Optional array of tools that can be used by the model
- * @param params.kvCache - Optional boolean to enable KV cache for faster subsequent completions
+ * @param params.kvCache - Optional KV cache configuration. Cache files are organized hierarchically:
+ *   - Structure: `{kvCacheKey}/{modelId}/{configHash}.bin`
+ *   - The configHash includes model config + system prompt to ensure cache isolation
+ *   - `true`: Auto-generate cache key based on conversation history
+ *   - `"custom-key"`: Use provided string as cache key for manual session management
+ *   - `false` or `undefined`: No caching
+ *   - ⚡ Performance: When cache exists, only the last message is sent to the model (includes multimodal attachments)
+ *   - 🗑️ Cleanup: Use `deleteCache({ kvCacheKey })` to remove cached sessions
  * @returns Object with tokenStream generator, text promise, and stats promise
  * @example
  * ```typescript
- * // Streaming mode
+ * // Streaming mode with auto-generated cache
  * const result = completion({
  *   modelId: "llama-2",
  *   history: [
  *     { role: "user", content: "Hello, how are you?" }
  *   ],
  *   stream: true,
+ *   kvCache: true, // Auto-generate cache key
  * });
  *
  * for await (const token of result.tokenStream) {
  *   console.log(token);
  * }
  *
- * const stats = await result.stats;
- * console.log("Performance:", stats);
+ * // Custom session management with cache key
+ * const sessionResult = completion({
+ *   modelId: "llama-2",
+ *   history: [
+ *     { role: "user", content: "Continue our conversation" }
+ *   ],
+ *   stream: true,
+ *   kvCache: "user-session-123", // Custom cache key
+ * });
  *
  * // Non-streaming mode
  * const response = completion({

package/dist/client/api/completion-stream.js

@@ -8,25 +8,40 @@ import { stream as streamRpc } from "../rpc/rpc-client.js";
  * @param params.history - Array of conversation messages with role, content, and optional attachments
  * @param params.stream - Whether to stream tokens (true) or return complete response (false). Defaults to true
  * @param params.tools - Optional array of tools that can be used by the model
- * @param params.kvCache - Optional boolean to enable KV cache for faster subsequent completions
+ * @param params.kvCache - Optional KV cache configuration. Cache files are organized hierarchically:
+ *   - Structure: `{kvCacheKey}/{modelId}/{configHash}.bin`
+ *   - The configHash includes model config + system prompt to ensure cache isolation
+ *   - `true`: Auto-generate cache key based on conversation history
+ *   - `"custom-key"`: Use provided string as cache key for manual session management
+ *   - `false` or `undefined`: No caching
+ *   - ⚡ Performance: When cache exists, only the last message is sent to the model (includes multimodal attachments)
+ *   - 🗑️ Cleanup: Use `deleteCache({ kvCacheKey })` to remove cached sessions
  * @returns Object with tokenStream generator, text promise, and stats promise
  * @example
  * ```typescript
- * // Streaming mode
+ * // Streaming mode with auto-generated cache
  * const result = completion({
  *   modelId: "llama-2",
  *   history: [
  *     { role: "user", content: "Hello, how are you?" }
  *   ],
  *   stream: true,
+ *   kvCache: true, // Auto-generate cache key
  * });
  *
  * for await (const token of result.tokenStream) {
  *   console.log(token);
  * }
  *
- * const stats = await result.stats;
- * console.log("Performance:", stats);
+ * // Custom session management with cache key
+ * const sessionResult = completion({
+ *   modelId: "llama-2",
+ *   history: [
+ *     { role: "user", content: "Continue our conversation" }
+ *   ],
+ *   stream: true,
+ *   kvCache: "user-session-123", // Custom cache key
+ * });
  *
  * // Non-streaming mode
  * const response = completion({

package/dist/client/api/delete-cache.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Deletes KV cache files.
+ *
+ * @param params - The delete cache parameters
+ * @param params.all - If true, deletes all cache files
+ * @param params.kvCacheKey - The cache key to delete
+ * @param params.modelId - Optional: specific model ID to delete within the cache key. If not provided, deletes entire cache key.
+ * @returns Promise resolving to success status
+ * @example
+ * ```typescript
+ * // Delete all caches
+ * await deleteCache({ all: true });
+ *
+ * // Delete entire cache key (all models)
+ * await deleteCache({ kvCacheKey: "my-session" });
+ *
+ * // Delete only specific model within cache key
+ * await deleteCache({ kvCacheKey: "my-session", modelId: "model-abc123" });
+ * ```
+ */
+export declare function deleteCache(params: {
+    all: true;
+} | {
+    kvCacheKey: string;
+    modelId?: string;
+}): Promise<{
+    success: boolean;
+}>;
+//# sourceMappingURL=delete-cache.d.ts.map

package/dist/client/api/delete-cache.js

@@ -0,0 +1,47 @@
+import { send } from "../rpc/rpc-client.js";
+/**
+ * Deletes KV cache files.
+ *
+ * @param params - The delete cache parameters
+ * @param params.all - If true, deletes all cache files
+ * @param params.kvCacheKey - The cache key to delete
+ * @param params.modelId - Optional: specific model ID to delete within the cache key. If not provided, deletes entire cache key.
+ * @returns Promise resolving to success status
+ * @example
+ * ```typescript
+ * // Delete all caches
+ * await deleteCache({ all: true });
+ *
+ * // Delete entire cache key (all models)
+ * await deleteCache({ kvCacheKey: "my-session" });
+ *
+ * // Delete only specific model within cache key
+ * await deleteCache({ kvCacheKey: "my-session", modelId: "model-abc123" });
+ * ```
+ */
+export async function deleteCache(params) {
+    let req;
+    if ("all" in params && params.all) {
+        req = {
+            type: "deleteCache",
+            all: true,
+        };
+    }
+    else if ("kvCacheKey" in params) {
+        req = {
+            type: "deleteCache",
+            kvCacheKey: params.kvCacheKey,
+            modelId: params.modelId,
+        };
+    }
+    else {
+        throw new Error("Invalid deleteCache parameters");
+    }
+    const response = (await send(req));
+    if (!response.success && response.error) {
+        throw new Error(response.error);
+    }
+    return {
+        success: response.success,
+    };
+}

package/dist/client/api/index.d.ts

@@ -1,6 +1,7 @@
 export { loadModel } from "./load-model";
 export { downloadAsset } from "./download-asset";
 export { completion } from "./completion-stream";
+export { deleteCache } from "./delete-cache";
 export { unloadModel } from "./unload-model";
 export { loggingStream } from "./logging-stream";
 export { ping } from "./ping";

package/dist/client/api/index.js

@@ -1,6 +1,7 @@
 export { loadModel } from "./load-model.js";
 export { downloadAsset } from "./download-asset.js";
 export { completion } from "./completion-stream.js";
+export { deleteCache } from "./delete-cache.js";
 export { unloadModel } from "./unload-model.js";
 export { loggingStream } from "./logging-stream.js";
 export { ping } from "./ping.js";

package/dist/client/rpc/bare-client.d.ts

@@ -11,8 +11,13 @@ export declare function stream<T extends Request>(request: T): AsyncGenerator<{
     stats?: {
         timeToFirstToken: number;
         tokensPerSecond: number;
+        cacheTokens: number;
     } | undefined;
     error?: string | undefined;
+} | {
+    type: "deleteCache";
+    success: boolean;
+    error?: string | undefined;
 } | {
     type: "modelProgress";
     downloaded: number;

package/dist/examples/kv-cache-cleanup.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=kv-cache-cleanup.d.ts.map

package/dist/examples/kv-cache-cleanup.js

@@ -0,0 +1,88 @@
+import { completion, deleteCache, LLAMA_3_2_1B_INST_Q4_0, loadModel, unloadModel, VERBOSITY, } from "@qvac/sdk";
+try {
+    console.log("🧹 KV Cache Cleanup Demo\n");
+    console.log("Cache structure: {kvCacheKey}/{modelId}/{configHash}.bin\n");
+    console.log("=".repeat(70) + "\n");
+    const modelId = await loadModel({
+        modelSrc: LLAMA_3_2_1B_INST_Q4_0,
+        modelType: "llm",
+        modelConfig: {
+            device: "gpu",
+            ctx_size: 2048,
+            verbosity: VERBOSITY.SILENT,
+        },
+    });
+    // Create some cached sessions
+    const cacheKey1 = "user-alice-session";
+    const cacheKey2 = "user-bob-session";
+    console.log(`📝 Creating cache for key: "${cacheKey1}"`);
+    const result1 = completion({
+        modelId,
+        history: [{ role: "user", content: "Hello, I'm Alice!" }],
+        stream: true,
+        kvCache: cacheKey1,
+    });
+    for await (const token of result1.tokenStream) {
+        process.stdout.write(token);
+    }
+    console.log("\n✅ Cache created\n");
+    console.log(`📝 Creating cache for key: "${cacheKey2}"`);
+    const result2 = completion({
+        modelId,
+        history: [{ role: "user", content: "Hello, I'm Bob!" }],
+        stream: true,
+        kvCache: cacheKey2,
+    });
+    for await (const token of result2.tokenStream) {
+        process.stdout.write(token);
+    }
+    console.log("\n✅ Cache created\n");
+    // Now cleanup specific cache key
+    console.log("=".repeat(70));
+    console.log(`\n🗑️  Deleting cache key: "${cacheKey1}"`);
+    const deleteResult1 = await deleteCache({ kvCacheKey: cacheKey1 });
+    if (deleteResult1.success) {
+        console.log(`✅ Deleted all caches for key "${cacheKey1}"`);
+        console.log(`   (Removed: ${cacheKey1}/{modelId}/{configHash}.bin)`);
+    }
+    // Delete specific model within a cache key
+    console.log(`\n🗑️  Deleting specific model in cache key: "${cacheKey2}"`);
+    const deleteResult2 = await deleteCache({
+        kvCacheKey: cacheKey2,
+        modelId: modelId,
+    });
+    if (deleteResult2.success) {
+        console.log(`✅ Deleted model "${modelId}" from cache key "${cacheKey2}"`);
+        console.log(`   (Removed: ${cacheKey2}/${modelId}/)`);
+    }
+    // Try to delete non-existent cache key (should succeed silently)
+    console.log(`\n🗑️  Deleting non-existent cache key: "non-existent"`);
+    const deleteResult3 = await deleteCache({ kvCacheKey: "non-existent" });
+    if (deleteResult3.success) {
+        console.log("✅ Delete succeeded (cache key didn't exist)");
+    }
+    console.log("\n" + "=".repeat(70));
+    console.log("\n✅ CLEANUP OPTIONS:");
+    console.log("-".repeat(70));
+    console.log("\n1️⃣  Delete entire cache key (all models):");
+    console.log('   await deleteCache({ kvCacheKey: "my-session" })');
+    console.log("   └─ Removes: my-session/ (entire directory)");
+    console.log("\n2️⃣  Delete specific model within cache key:");
+    console.log('   await deleteCache({ kvCacheKey: "my-session", modelId: "model-abc" })');
+    console.log("   └─ Removes: my-session/model-abc/ (specific model directory)");
+    console.log("\n3️⃣  Delete ALL caches (entire cache folder):");
+    console.log("   await deleteCache({ all: true })");
+    console.log("   └─ Removes: ALL cache files from all sessions and models");
+    console.log("\n💡 Use Cases:");
+    console.log("   - User logout → Delete user's cache key");
+    console.log("   - Model updated → Delete old model caches");
+    console.log("   - Disk space cleanup → Delete old cache keys or all caches");
+    console.log("   - Privacy → Clear conversation history");
+    console.log("   - App reset → Delete all caches with { all: true }");
+    await unloadModel({ modelId, clearStorage: false });
+    process.exit(0);
+}
+catch (error) {
+    console.error("❌ Error:", error);
+    process.exit(1);
+}

package/dist/examples/kv-cache-custom-key.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=kv-cache-custom-key.d.ts.map

package/dist/examples/kv-cache-custom-key.js

@@ -0,0 +1,87 @@
+import { completion, deleteCache, LLAMA_3_2_1B_INST_Q4_0, loadModel, unloadModel, VERBOSITY, } from "@qvac/sdk";
+const systemPromptMessage = {
+    role: "system",
+    content: `You are a helpful mathematician assistant. 
+   But because you are in the army you have to follow these rules:
+  - If anyone ask you to do an operation you have to answer with "Sir Yes Sir!" and then give the result
+  `,
+};
+try {
+    console.log("🧪 Simple KV Cache Demo: Same vs Different Cache Keys\n");
+    const modelId = await loadModel({
+        modelSrc: LLAMA_3_2_1B_INST_Q4_0,
+        modelType: "llm",
+        modelConfig: {
+            device: "gpu",
+            ctx_size: 2048,
+            verbosity: VERBOSITY.SILENT,
+        },
+    });
+    // Prompt 1 with cache key "session-a" (first time - no cache exists)
+    console.log('📝 Prompt 1: "What is 2+2?" with cache key "session-a"');
+    console.log("   Status: Creating NEW cache (first time)\n");
+    const result1 = completion({
+        modelId,
+        history: [systemPromptMessage, { role: "user", content: "What is 2+2?" }],
+        stream: true,
+        kvCache: "session-a",
+    });
+    console.log("   Response: ");
+    let response1 = "";
+    for await (const token of result1.tokenStream) {
+        response1 += token;
+        process.stdout.write(token);
+    }
+    const stats1 = await result1.stats;
+    console.log(`\n   Stats: TTFT=${stats1?.timeToFirstToken}ms, CacheTokens=${stats1?.cacheTokens}\n`);
+    // Prompt 2 with SAME cache key "session-a" (cache exists - optimized!)
+    // This continues the conversation - asking about the previous answer
+    console.log('\n📝 Prompt 2: "Now multiply that result by 3" with cache key "session-a" (SAME)');
+    console.log("   Status: REUSING existing cache (only last message sent, but context remembered!)\n");
+    const result2 = completion({
+        modelId,
+        history: [
+            systemPromptMessage,
+            { role: "user", content: "What is 2+2?" },
+            { role: "assistant", content: response1 },
+            { role: "user", content: "Now multiply that result by 3" }, // Refers to previous answer!
+        ],
+        stream: true,
+        kvCache: "session-a", // Same cache key!
+    });
+    console.log("   Response: ");
+    for await (const token of result2.tokenStream) {
+        process.stdout.write(token);
+    }
+    const stats2 = await result2.stats;
+    console.log(`\n   Stats: TTFT=${stats2?.timeToFirstToken}ms, CacheTokens=${stats2?.cacheTokens}\n`);
+    // Prompt 3 with DIFFERENT cache key "session-b" (new cache)
+    console.log('\n📝 Prompt 3: "What is 10+10?" with cache key "session-b" (DIFFERENT)');
+    console.log("   Status: Creating NEW cache (different key = isolated cache)\n");
+    const result3 = completion({
+        modelId,
+        history: [systemPromptMessage, { role: "user", content: "What is 10+10?" }],
+        stream: true,
+        kvCache: "session-b", // Different cache key!
+    });
+    console.log("   Response: ");
+    for await (const token of result3.tokenStream) {
+        process.stdout.write(token);
+    }
+    const stats3 = await result3.stats;
+    console.log(`\n   Stats: TTFT=${stats3?.timeToFirstToken}ms, CacheTokens=${stats3?.cacheTokens}\n`);
+    // Summary
+    console.log("\n✅ Summary:");
+    console.log('   - Prompts 1 & 2 share cache key "session-a" → same cache file');
+    console.log("   - Prompt 2 built on Prompt 1's context (model remembered the answer!)");
+    console.log("   - Only the last message was sent, but full conversation context maintained");
+    console.log('   - Prompt 3 uses cache key "session-b" → separate cache file (isolated)');
+    console.log("   - Different cache keys provide complete isolation between sessions");
+    await deleteCache({ all: true });
+    await unloadModel({ modelId, clearStorage: false });
+    process.exit(0);
+}
+catch (error) {
+    console.error("❌ Error:", error);
+    process.exit(1);
+}

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export { completion, loadModel, downloadAsset, ping, startQVACProvider, unloadModel, transcribe, transcribeStream, embed, translate, cancel, ragSaveEmbeddings, ragSearch, ragDeleteEmbeddings, } from "./client/api/index";
+export { completion, deleteCache, loadModel, downloadAsset, ping, startQVACProvider, unloadModel, transcribe, transcribeStream, embed, translate, cancel, ragSaveEmbeddings, ragSearch, ragDeleteEmbeddings, } from "./client/api/index";
 export { type ModelProgressUpdate, type LoadModelOptions, type DownloadAssetOptions, type Tool, VERBOSITY, type Attachment, type CompletionParams, type RagSearchResult, type RagSaveEmbeddingsResult, } from "./schemas/index";
 export * from "./models/hyperdrive/index";
 export { SUPPORTED_AUDIO_FORMATS } from "./constants/audio";

package/dist/index.js

@@ -1,5 +1,5 @@
 // Public API exports only
-export { completion, loadModel, downloadAsset, ping, startQVACProvider, unloadModel, transcribe, transcribeStream, embed, translate, cancel, ragSaveEmbeddings, ragSearch, ragDeleteEmbeddings, } from "./client/api/index.js";
+export { completion, deleteCache, loadModel, downloadAsset, ping, startQVACProvider, unloadModel, transcribe, transcribeStream, embed, translate, cancel, ragSaveEmbeddings, ragSearch, ragDeleteEmbeddings, } from "./client/api/index.js";
 export { VERBOSITY, } from "./schemas/index.js";
 // Hyperdrive model constants
 export * from "./models/hyperdrive/index.js";

package/dist/schemas/common.d.ts

@@ -25,7 +25,7 @@ export declare const requestSchema: z.ZodUnion<readonly [z.ZodObject<{
         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>;
+        system_prompt: z.ZodDefault<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>;
@@ -186,13 +186,13 @@ export declare const requestSchema: z.ZodUnion<readonly [z.ZodObject<{
         ctx_size: number;
         gpu_layers: number;
         device: string;
+        system_prompt: string;
         temp?: number | undefined;
         top_p?: number | undefined;
         top_k?: number | undefined;
         seed?: number | undefined;
         lora?: string | undefined;
         predict?: number | undefined;
-        system_prompt?: string | undefined;
         no_mmap?: boolean | undefined;
         verbosity?: 0 | 1 | -1 | undefined;
         presence_penalty?: number | undefined;
@@ -283,13 +283,13 @@ export declare const requestSchema: z.ZodUnion<readonly [z.ZodObject<{
         ctx_size: number;
         gpu_layers: number;
         device: string;
+        system_prompt: string;
         temp?: number | undefined;
         top_p?: number | undefined;
         top_k?: number | undefined;
         seed?: number | undefined;
         lora?: string | undefined;
         predict?: number | undefined;
-        system_prompt?: string | undefined;
         no_mmap?: boolean | undefined;
         verbosity?: 0 | 1 | -1 | undefined;
         presence_penalty?: number | undefined;
@@ -419,7 +419,7 @@ export declare const requestSchema: z.ZodUnion<readonly [z.ZodObject<{
         }, z.core.$strip>;
     }, z.core.$strip>>>;
     stream: z.ZodBoolean;
-    kvCache: z.ZodOptional<z.ZodBoolean>;
+    kvCache: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>;
     type: z.ZodLiteral<"completionStream">;
 }, z.core.$strip>, z.ZodObject<{
     modelId: z.ZodString;
@@ -505,7 +505,14 @@ export declare const requestSchema: z.ZodUnion<readonly [z.ZodObject<{
     ids: z.ZodArray<z.ZodString>;
     type: z.ZodLiteral<"rag">;
     operation: z.ZodLiteral<"deleteEmbeddings">;
-}, z.core.$strip>], "operation">]>;
+}, z.core.$strip>], "operation">, z.ZodUnion<readonly [z.ZodObject<{
+    type: z.ZodLiteral<"deleteCache">;
+    all: z.ZodLiteral<true>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"deleteCache">;
+    kvCacheKey: z.ZodString;
+    modelId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>]>]>;
 export declare const responseSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     type: z.ZodLiteral<"pong">;
     number: z.ZodNumber;
@@ -526,6 +533,7 @@ export declare const responseSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     stats: z.ZodOptional<z.ZodObject<{
         timeToFirstToken: z.ZodNumber;
         tokensPerSecond: z.ZodNumber;
+        cacheTokens: z.ZodNumber;
     }, z.core.$strip>>;
     error: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>, z.ZodObject<{
@@ -616,7 +624,11 @@ export declare const responseSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     success: z.ZodBoolean;
     error: z.ZodOptional<z.ZodString>;
     operation: z.ZodLiteral<"deleteEmbeddings">;
-}, z.core.$strip>], "operation">], "type">;
+}, z.core.$strip>], "operation">, z.ZodObject<{
+    type: z.ZodLiteral<"deleteCache">;
+    success: z.ZodBoolean;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>], "type">;
 export declare const rpcOptionsSchema: z.ZodObject<{
     timeout: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;

package/dist/schemas/common.js

@@ -12,6 +12,7 @@ import { translateRequestSchema, translateResponseSchema } from "./translate.js"
 import { loggingStreamRequestSchema, loggingStreamResponseSchema, } from "./logging-stream.js";
 import { errorResponseSchema } from "./error.js";
 import { ragRequestSchema, ragResponseSchema } from "./rag.js";
+import { deleteCacheRequestSchema, deleteCacheResponseSchema, } from "./delete-cache.js";
 export const requestSchema = z.union([
     pingRequestSchema,
     loadModelRequestSchema,
@@ -25,6 +26,7 @@ export const requestSchema = z.union([
     cancelRequestSchema,
     provideRequestSchema,
     ragRequestSchema,
+    deleteCacheRequestSchema,
 ]);
 export const responseSchema = z.discriminatedUnion("type", [
     pingResponseSchema,
@@ -41,6 +43,7 @@ export const responseSchema = z.discriminatedUnion("type", [
     provideResponseSchema,
     errorResponseSchema,
     ragResponseSchema,
+    deleteCacheResponseSchema,
 ]);
 export const rpcOptionsSchema = z.object({
     timeout: z.number().min(100).optional(),

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

@@ -32,7 +32,7 @@ export declare const completionParamsSchema: z.ZodObject<{
         }, z.core.$strip>>>;
     }, z.core.$strip>>;
     modelId: z.ZodString;
-    kvCache: z.ZodOptional<z.ZodBoolean>;
+    kvCache: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>;
 }, z.core.$strip>;
 export declare const completionClientParamsSchema: z.ZodObject<{
     history: z.ZodArray<z.ZodObject<{
@@ -65,7 +65,7 @@ export declare const completionClientParamsSchema: z.ZodObject<{
         }, z.core.$strip>;
     }, z.core.$strip>>>;
     stream: z.ZodBoolean;
-    kvCache: z.ZodOptional<z.ZodBoolean>;
+    kvCache: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>;
 }, z.core.$strip>;
 export declare const completionStreamRequestSchema: z.ZodObject<{
     history: z.ZodArray<z.ZodObject<{
@@ -98,12 +98,13 @@ export declare const completionStreamRequestSchema: z.ZodObject<{
         }, z.core.$strip>;
     }, z.core.$strip>>>;
     stream: z.ZodBoolean;
-    kvCache: z.ZodOptional<z.ZodBoolean>;
+    kvCache: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>;
     type: z.ZodLiteral<"completionStream">;
 }, z.core.$strip>;
 export declare const completionStatsSchema: z.ZodObject<{
     timeToFirstToken: z.ZodNumber;
     tokensPerSecond: z.ZodNumber;
+    cacheTokens: z.ZodNumber;
 }, z.core.$strip>;
 export declare const completionStreamResponseSchema: z.ZodObject<{
     type: z.ZodLiteral<"completionStream">;
@@ -112,6 +113,7 @@ export declare const completionStreamResponseSchema: z.ZodObject<{
     stats: z.ZodOptional<z.ZodObject<{
         timeToFirstToken: z.ZodNumber;
         tokensPerSecond: z.ZodNumber;
+        cacheTokens: z.ZodNumber;
     }, z.core.$strip>>;
     error: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;

package/dist/schemas/completion-stream.js

@@ -30,12 +30,12 @@ export const completionParamsSchema = z.object({
         attachments: z.array(attachmentSchema).optional(),
     })),
     modelId: z.string(),
-    kvCache: z.boolean().optional(),
+    kvCache: z.union([z.boolean(), z.string()]).optional(),
 });
 export const completionClientParamsSchema = completionParamsSchema.extend({
     tools: z.array(toolSchema).optional(),
     stream: z.boolean(),
-    kvCache: z.boolean().optional(),
+    kvCache: z.union([z.boolean(), z.string()]).optional(),
 });
 export const completionStreamRequestSchema = completionClientParamsSchema.extend({
     type: z.literal("completionStream"),
@@ -43,6 +43,7 @@ export const completionStreamRequestSchema = completionClientParamsSchema.extend
 export const completionStatsSchema = z.object({
     timeToFirstToken: z.number(),
     tokensPerSecond: z.number(),
+    cacheTokens: z.number(),
 });
 export const completionStreamResponseSchema = z.object({
     type: z.literal("completionStream"),

package/dist/schemas/delete-cache.d.ts

@@ -0,0 +1,17 @@
+import { z } from "zod";
+export declare const deleteCacheRequestSchema: z.ZodUnion<readonly [z.ZodObject<{
+    type: z.ZodLiteral<"deleteCache">;
+    all: z.ZodLiteral<true>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"deleteCache">;
+    kvCacheKey: z.ZodString;
+    modelId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>]>;
+export declare const deleteCacheResponseSchema: z.ZodObject<{
+    type: z.ZodLiteral<"deleteCache">;
+    success: z.ZodBoolean;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type DeleteCacheRequest = z.infer<typeof deleteCacheRequestSchema>;
+export type DeleteCacheResponse = z.infer<typeof deleteCacheResponseSchema>;
+//# sourceMappingURL=delete-cache.d.ts.map

package/dist/schemas/delete-cache.js

@@ -0,0 +1,17 @@
+import { z } from "zod";
+export const deleteCacheRequestSchema = z.union([
+    z.object({
+        type: z.literal("deleteCache"),
+        all: z.literal(true),
+    }),
+    z.object({
+        type: z.literal("deleteCache"),
+        kvCacheKey: z.string(),
+        modelId: z.string().optional(),
+    }),
+]);
+export const deleteCacheResponseSchema = z.object({
+    type: z.literal("deleteCache"),
+    success: z.boolean(),
+    error: z.string().optional(),
+});

package/dist/schemas/index.d.ts

@@ -1,6 +1,7 @@
 export * from "./cancel";
 export * from "./completion-stream";
 export * from "./delegate";
+export * from "./delete-cache";
 export * from "./download-asset";
 export * from "./embed";
 export * from "./load-model";

package/dist/schemas/index.js

@@ -2,6 +2,7 @@
 export * from "./cancel.js";
 export * from "./completion-stream.js";
 export * from "./delegate.js";
+export * from "./delete-cache.js";
 export * from "./download-asset.js";
 export * from "./embed.js";
 export * from "./load-model.js";