@qvac/sdk 0.2.7-dev.1761566029.f834aa3 → 0.4.0

package/dist/server/rpc/handlers/load-model/resolve.js

@@ -1,46 +1,11 @@
-import { getModelBySrc, models } from "../../../../models/hyperdrive/models.js";
+import { models } from "../../../../models/hyperdrive/models.js";
 import { hyperdriveUrlSchema } from "../../../../schemas/index.js";
 import { getModelsCacheDir } from "../../../utils/index.js";
 import { promises as fsPromises } from "bare-fs";
 import path from "bare-path";
 import { downloadModelFromHttp } from "./http.js";
 import { downloadModelFromHyperdrive } from "./hyperdrive.js";
-/**
- * Attempts to resolve a model from cache (without validation)
- * Validation will be handled by the hyperdrive download logic
- */
-async function tryResolveCachedModel(modelId) {
-    const cacheDir = getModelsCacheDir();
-    const cachedPath = path.join(cacheDir, modelId);
-    try {
-        await fsPromises.access(cachedPath);
-        // File exists - return null to let hyperdrive validation handle size/checksum
-        // This ensures partial downloads are properly resumed instead of being
-        // incorrectly validated and deleted
-        return null;
-    }
-    catch {
-        // File doesn't exist
-        return null;
-    }
-}
-/**
- * Resolves a known model by ID from hyperdrive, checking cache first
- */
-async function resolveKnownModel(model, modelIdOrPath, progressCallback, seed) {
-    if (!model) {
-        throw new Error("Model is null");
-    }
-    console.log(`Loading model ID '${modelIdOrPath}' from hyperdrive`);
-    // Try to resolve from cache first
-    const cachedPath = await tryResolveCachedModel(model.modelId);
-    if (cachedPath) {
-        return cachedPath;
-    }
-    // Not cached or invalid, download from hyperdrive
-    const downloadedPath = await downloadModelFromHyperdrive(model.hyperdriveKey, model.modelId, seed, progressCallback, model.sha256Checksum);
-    return downloadedPath;
-}
+import { ModelLoadFailedError, ModelNotFoundError, SeedingNotSupportedError, } from "../../../../utils/errors-server.js";
 /**
  * Resolves a local file path or cached file
  */
@@ -48,7 +13,7 @@ async function resolveLocalOrCachedFile(modelIdOrPath) {
     // Check if it's a hex string (arbitrary hyperdrive key)
     const isHexString = /^[0-9a-fA-F]{64}$/.test(modelIdOrPath);
     if (isHexString) {
-        throw new Error(`Direct hyperdrive keys not supported. Use hyperdriveKey parameter instead. Example: loadModel("model.gguf", "${modelIdOrPath}")`);
+        throw new ModelLoadFailedError(`Direct hyperdrive keys not supported. Use hyperdriveKey parameter instead. Example: loadModel("model.gguf", "${modelIdOrPath}")`);
     }
     // Check if it's a cached file or local file
     const cacheDir = getModelsCacheDir();
@@ -68,26 +33,26 @@ async function resolveLocalOrCachedFile(modelIdOrPath) {
         catch {
             // Invalid model ID - provide helpful error
             const availableModels = models.map((m) => m.modelId);
-            throw new Error(`Invalid model ID: "${modelIdOrPath}". Available models: ${availableModels.join(", ")}`);
+            throw new ModelNotFoundError(`${modelIdOrPath}". Available models: ${availableModels.join(", ")}`);
         }
     }
 }
+import { modelInputToSrcSchema } from "../../../../schemas/index.js";
 export async function resolveModelPath(modelSrc, progressCallback, seed) {
+    // Extract src and validate using Zod schema transform
+    const srcString = modelInputToSrcSchema.parse(modelSrc);
     // Parse hyperdrive URLs if present
     let hyperdriveKey;
-    let actualModelSrc = modelSrc;
-    if (modelSrc.startsWith("pear://")) {
-        const { key, path } = hyperdriveUrlSchema.parse(modelSrc);
+    let actualModelSrc = srcString;
+    if (srcString.startsWith("pear://")) {
+        const { key, path } = hyperdriveUrlSchema.parse(srcString);
         hyperdriveKey = key;
         actualModelSrc = path;
     }
     let actualPath;
     // Validate seeding is only used with hyperdrive models
     if (seed && !hyperdriveKey) {
-        const model = getModelBySrc(actualModelSrc);
-        if (!model) {
-            throw new Error("Seeding is only supported for hyperdrive models");
-        }
+        throw new SeedingNotSupportedError();
     }
     // Check if it's an HTTP/HTTPS URL
     if (actualModelSrc.startsWith("http://") ||
@@ -101,21 +66,13 @@ export async function resolveModelPath(modelSrc, progressCallback, seed) {
         console.log(`Loading from hyperdrive: ${hyperdriveKey}`);
         actualPath = await downloadModelFromHyperdrive(hyperdriveKey, actualModelSrc, seed, progressCallback);
     }
+    else if (actualModelSrc.includes("/") || actualModelSrc.includes("\\")) {
+        // Handle file paths (absolute or relative with slashes)
+        actualPath = actualModelSrc;
+    }
     else {
-        // Try to resolve as a known model ID
-        const model = getModelBySrc(actualModelSrc);
-        if (model) {
-            actualPath = await resolveKnownModel(model, actualModelSrc, progressCallback, seed);
-        }
-        else if (actualModelSrc.includes("/") || actualModelSrc.includes("\\")) {
-            // Handle file paths (absolute or relative with slashes)
-            console.log(`Loading from file: ${actualModelSrc}`);
-            actualPath = actualModelSrc;
-        }
-        else {
-            // Handle local files and cached files
-            actualPath = await resolveLocalOrCachedFile(actualModelSrc);
-        }
+        // Handle local files and cached files
+        actualPath = await resolveLocalOrCachedFile(actualModelSrc);
     }
     return actualPath;
 }

package/dist/server/rpc/handlers/load-model-delegated.js

@@ -1,10 +1,12 @@
+import { modelInputToSrcSchema } from "../../../schemas/index.js";
 import { registerModel } from "../../bare/registry/model-registry.js";
 import { getRPC } from "../../bare/delegate-rpc-client.js";
 import { send, stream } from "../../../client/rpc/rpc-client.js";
 import { handleLoadModel } from "./load-model/index.js";
+import { ModelLoadFailedError, DelegateNoFinalResponseError, } from "../../../utils/errors-server.js";
 export async function handleLoadModelDelegated(request, progressCallback) {
     if (!request.delegate) {
-        throw new Error("Delegate information is required for delegated load model");
+        throw new ModelLoadFailedError("Delegate information is required for delegated load model");
     }
     const { delegate } = request;
     const { topic, providerPublicKey, timeout, fallbackToLocal } = delegate;
@@ -33,7 +35,7 @@ export async function handleLoadModelDelegated(request, progressCallback) {
                 }
             }
             if (!finalResponse) {
-                throw new Error("No final response received from provider");
+                throw new DelegateNoFinalResponseError();
             }
         }
         else {
@@ -49,8 +51,9 @@ export async function handleLoadModelDelegated(request, progressCallback) {
                 error: `Provider failed to load model: ${finalResponse?.error || "Unknown error"}`,
             };
         }
-        // Register the delegated model with provider info
-        const modelId = finalResponse.modelId || request.modelSrc || `delegated-${Date.now()}`;
+        const modelId = finalResponse.modelId ||
+            modelInputToSrcSchema.parse(request.modelSrc) ||
+            `delegated-${Date.now()}`;
         const delegateOptions = {
             topic,
             providerPublicKey,

package/dist/server/rpc/handlers/load-model.js

@@ -1,8 +1,12 @@
 import { loadModel } from "../../bare/addons/index.js";
 import { resolveModelPath } from "./load-model/resolve.js";
 import { generateShortHash } from "../../utils/index.js";
+import { TTSConfigModelRequiredError, ESpeakDataPathRequiredError, } from "../../../utils/errors-server.js";
 export async function handleLoadModel(request, progressCallback) {
-    const { modelSrc, seed, projectionModelSrc, vadModelSrc } = request;
+    const { modelSrc, modelName, seed, projectionModelSrc, vadModelSrc, configSrc, } = request;
+    const eSpeakDataPath = request.modelType === "tts"
+        ? request.eSpeakDataPath
+        : undefined;
     try {
         const modelPath = await resolveModelPath(modelSrc, progressCallback, seed);
         let projectionModelPath;
@@ -13,6 +17,17 @@ export async function handleLoadModel(request, progressCallback) {
         if (vadModelSrc) {
             vadModelPath = await resolveModelPath(vadModelSrc, progressCallback, seed);
         }
+        let ttsConfigModelPath;
+        if (configSrc) {
+            ttsConfigModelPath = await resolveModelPath(configSrc, progressCallback, seed);
+        }
+        // For TTS models, ttsConfigModelPath and eSpeakDataPath are required
+        if (request.modelType === "tts" && !ttsConfigModelPath) {
+            throw new TTSConfigModelRequiredError();
+        }
+        if (request.modelType === "tts" && !eSpeakDataPath) {
+            throw new ESpeakDataPathRequiredError();
+        }
         // Generate hash-based modelId
         const configStr = JSON.stringify(request.modelConfig, Object.keys(request.modelConfig).sort());
         const modelHashInput = `${request.modelType}:${modelSrc}:${configStr}`;
@@ -23,6 +38,9 @@ export async function handleLoadModel(request, progressCallback) {
             options: request,
             projectionModelPath,
             vadModelPath,
+            ttsConfigModelPath,
+            eSpeakDataPath,
+            modelName,
         });
         return {
             type: "loadModel",

package/dist/server/rpc/handlers/provideHandler/handler.js

@@ -1,4 +1,4 @@
-import { getSwarm } from "../../../bare/hyperswarm.js";
+import { getSwarm, registerProviderTopic } from "../../../bare/hyperswarm.js";
 import { setupConnectionHandlers } from "./connection.js";
 export async function provideHandler(request) {
     const swarm = getSwarm({
@@ -27,6 +27,7 @@ export async function provideHandler(request) {
         console.log(`🎯 Ready to accept connections on topic: ${topic.toString("hex").substring(0, 16)}...`);
         // Handle incoming connections
         setupConnectionHandlers(swarm);
+        registerProviderTopic(topic.toString("hex"));
         console.log("🏁 About to return success response...");
         const response = {
             type: "provide",

package/dist/server/rpc/handlers/rag.js

@@ -29,9 +29,6 @@ export async function handleRag(request) {
                     success,
                 };
             }
-            default: {
-                throw new Error(`Unknown RAG operation`);
-            }
         }
     }
     catch (error) {

package/dist/server/rpc/handlers/set-config.d.ts

@@ -0,0 +1,3 @@
+import type { SetConfigRequest, SetConfigResponse } from "../../../schemas/index";
+export declare const handleSetConfig: (request: SetConfigRequest) => SetConfigResponse;
+//# sourceMappingURL=set-config.d.ts.map

package/dist/server/rpc/handlers/set-config.js

@@ -0,0 +1,18 @@
+import { setSDKConfig } from "../../bare/registry/config-registry.js";
+export const handleSetConfig = (request) => {
+    try {
+        setSDKConfig(request.config);
+        return {
+            type: "setConfig",
+            success: true,
+        };
+    }
+    catch (error) {
+        console.error("Error setting config:", error);
+        return {
+            type: "setConfig",
+            success: false,
+            error: error instanceof Error ? error.message : "Unknown error",
+        };
+    }
+};

package/dist/server/rpc/handlers/stopProvideHandler.d.ts

@@ -0,0 +1,3 @@
+import type { StopProvideRequest, StopProvideResponse } from "../../../schemas/stop-provide";
+export declare function stopProvideHandler(request: StopProvideRequest): StopProvideResponse;
+//# sourceMappingURL=stopProvideHandler.d.ts.map

package/dist/server/rpc/handlers/stopProvideHandler.js

@@ -0,0 +1,22 @@
+import { getSwarm, unregisterProviderTopic } from "../../bare/hyperswarm.js";
+export function stopProvideHandler(request) {
+    const swarm = getSwarm();
+    try {
+        const topic = Buffer.from(request.topic, "hex");
+        const topicHex = request.topic;
+        swarm.leave(topic);
+        unregisterProviderTopic(topicHex);
+        return {
+            type: "stopProvide",
+            success: true,
+        };
+    }
+    catch (error) {
+        console.error("❌ Error in stop provide handler:", error);
+        return {
+            type: "stopProvide",
+            success: false,
+            error: error instanceof Error ? error.message : "Unknown error",
+        };
+    }
+}

package/dist/server/rpc/handlers/text-to-speech.d.ts

@@ -0,0 +1,3 @@
+import type { TtsRequest, TtsResponse } from "../../../schemas/index";
+export declare function handleTextToSpeech(request: TtsRequest): AsyncGenerator<TtsResponse>;
+//# sourceMappingURL=text-to-speech.d.ts.map

package/dist/server/rpc/handlers/text-to-speech.js

@@ -0,0 +1,7 @@
+import { textToSpeech } from "../../bare/addons/tts/index.js";
+export async function* handleTextToSpeech(request) {
+    const stream = textToSpeech(request);
+    for await (const response of stream) {
+        yield response;
+    }
+}

package/dist/server/rpc/handlers/transcribe-stream.js

@@ -1,9 +1,13 @@
 import { transcribeStream } from "../../bare/addons/whispercpp/index.js";
 export async function* handleTranscribeStream(request) {
-    const { modelId, audioChunk } = request;
+    const { modelId, audioChunk, prompt } = request;
     try {
         // Stream transcription results in real-time
-        for await (const textChunk of transcribeStream({ audioChunk, modelId })) {
+        for await (const textChunk of transcribeStream({
+            audioChunk,
+            modelId,
+            prompt,
+        })) {
             yield {
                 type: "transcribeStream",
                 text: textChunk,

package/dist/server/rpc/handlers/unload-model.js

@@ -1,12 +1,19 @@
 import { unloadModel } from "../../bare/addons/index.js";
+import { getRegistryStats } from "../../bare/registry/model-registry.js";
+import { hasActiveProviders } from "../../bare/hyperswarm.js";
 export async function handleUnloadModel(request) {
     const { modelId, clearStorage } = request;
     try {
         console.log("Unloading model", modelId);
         await unloadModel({ modelId, clearStorage });
+        const stats = getRegistryStats();
+        const modelsActive = stats.totalModels > 0;
+        const providersActive = hasActiveProviders();
         return {
             type: "unloadModel",
             success: true,
+            hasActiveModels: modelsActive,
+            hasActiveProviders: providersActive,
         };
     }
     catch (error) {

package/dist/server/utils/cache.d.ts

@@ -1,15 +1,20 @@
+import type { ShardMetadata } from "./shard-utils";
+export declare const getCacheDir: (subDir: string) => string;
+export declare const getModelsCacheDir: () => string;
+export declare const getKVCacheDir: () => string;
 /**
- * Creates and returns cache directory path for the specified subdirectory
- * @param subDir - Subdirectory name (e.g., "models", "kv-cache")
- * @returns Full path to the cache directory
+ * Get cache directory for sharded model
+ * Returns: cache/sharded/<hyperdriveKey>/
  */
-export declare function getCacheDir(subDir: string): string;
+export declare function getShardedModelCacheDir(hyperdriveKey: string): string;
 /**
- * Legacy function for backward compatibility - gets models cache directory
+ * Get full path to specific shard file
+ * Returns: cache/sharded/<hyperdriveKey>/<shardFilename>
  */
-export declare function getModelsCacheDir(): string;
+export declare function getShardPath(hyperdriveKey: string, shardFilename: string): string;
 /**
- * Gets KV cache directory
+ * Check if all shards exist and are valid (size + checksum check)
+ * Returns array of missing/invalid shard indices (0-based)
  */
-export declare function getKVCacheDir(): string;
+export declare function checkShardCompleteness(hyperdriveKey: string, shardFilenames: readonly string[], shardMetadata: readonly ShardMetadata[]): Promise<number[]>;
 //# sourceMappingURL=cache.d.ts.map

package/dist/server/utils/cache.js

@@ -1,15 +1,11 @@
-import fs from "bare-fs";
+import fs, { promises as fsPromises } from "bare-fs";
 import path from "bare-path";
 import { getEnv } from "../worker.js";
-/**
- * Creates and returns cache directory path for the specified subdirectory
- * @param subDir - Subdirectory name (e.g., "models", "kv-cache")
- * @returns Full path to the cache directory
- */
-export function getCacheDir(subDir) {
+import { getConfiguredCacheDir } from "../bare/registry/config-registry.js";
+import { calculateFileChecksum } from "./checksum.js";
+export const getCacheDir = (subDir) => {
     const homeDir = getEnv().HOME_DIR;
     const cacheDir = path.join(homeDir, ".qvac", subDir);
-    // Ensure cache directory exists
     try {
         fs.mkdirSync(cacheDir, { recursive: true });
     }
@@ -17,16 +13,75 @@ export function getCacheDir(subDir) {
         console.error(`Error creating cache directory (${subDir}):`, error instanceof Error ? error.message : String(error));
     }
     return cacheDir;
+};
+export const getModelsCacheDir = () => {
+    const configuredDir = getConfiguredCacheDir();
+    try {
+        fs.mkdirSync(configuredDir, { recursive: true });
+    }
+    catch (error) {
+        console.error(`Error creating models cache directory:`, error instanceof Error ? error.message : String(error));
+    }
+    return configuredDir;
+};
+export const getKVCacheDir = () => {
+    return getCacheDir("kv-cache");
+};
+/**
+ * Get cache directory for sharded model
+ * Returns: cache/sharded/<hyperdriveKey>/
+ */
+export function getShardedModelCacheDir(hyperdriveKey) {
+    const baseCache = getModelsCacheDir();
+    const shardDir = path.join(baseCache, "sharded", hyperdriveKey);
+    try {
+        fs.mkdirSync(shardDir, { recursive: true });
+    }
+    catch (error) {
+        console.error(`Error creating sharded model cache directory:`, error instanceof Error ? error.message : String(error));
+    }
+    return shardDir;
 }
 /**
- * Legacy function for backward compatibility - gets models cache directory
+ * Get full path to specific shard file
+ * Returns: cache/sharded/<hyperdriveKey>/<shardFilename>
  */
-export function getModelsCacheDir() {
-    return getCacheDir("models");
+export function getShardPath(hyperdriveKey, shardFilename) {
+    const shardDir = getShardedModelCacheDir(hyperdriveKey);
+    return path.join(shardDir, shardFilename);
 }
 /**
- * Gets KV cache directory
+ * Check if all shards exist and are valid (size + checksum check)
+ * Returns array of missing/invalid shard indices (0-based)
  */
-export function getKVCacheDir() {
-    return getCacheDir("kv-cache");
+export async function checkShardCompleteness(hyperdriveKey, shardFilenames, shardMetadata) {
+    const invalidIndices = [];
+    for (let i = 0; i < shardFilenames.length; i++) {
+        const shardPath = getShardPath(hyperdriveKey, shardFilenames[i]);
+        const fileMeta = shardMetadata[i];
+        if (!fileMeta) {
+            invalidIndices.push(i);
+            continue;
+        }
+        try {
+            const stats = await fsPromises.stat(shardPath);
+            if (stats.size !== fileMeta.expectedSize) {
+                console.warn(`File ${i + 1} size mismatch: expected ${fileMeta.expectedSize}, got ${stats.size}`);
+                invalidIndices.push(i);
+                continue;
+            }
+            if (fileMeta.sha256Checksum) {
+                const actualChecksum = await calculateFileChecksum(shardPath);
+                if (actualChecksum !== fileMeta.sha256Checksum) {
+                    console.warn(`File ${i + 1} checksum mismatch for ${fileMeta.filename}. Expected: ${fileMeta.sha256Checksum}. Actual: ${actualChecksum}. Will re-download.`);
+                    invalidIndices.push(i);
+                }
+            }
+        }
+        catch {
+            // File doesn't exist
+            invalidIndices.push(i);
+        }
+    }
+    return invalidIndices;
 }

package/dist/server/utils/checksum.d.ts

@@ -0,0 +1,2 @@
+export declare function calculateFileChecksum(filePath: string): Promise<string>;
+//# sourceMappingURL=checksum.d.ts.map

package/dist/server/utils/checksum.js

@@ -0,0 +1,24 @@
+import fs from "bare-fs";
+import crypto from "bare-crypto";
+export async function calculateFileChecksum(filePath) {
+    return new Promise((resolve, reject) => {
+        try {
+            const hash = crypto.createHash("sha256");
+            const stream = fs.createReadStream(filePath);
+            stream.on("data", (chunk) => {
+                hash.update(chunk);
+            });
+            stream.on("end", () => {
+                resolve(hash.digest("hex"));
+            });
+            stream.on("error", (error) => {
+                reject(new Error(`Checksum calculation error: ${error.message}`));
+            });
+        }
+        catch (error) {
+            reject(error instanceof Error
+                ? error
+                : new Error(`Checksum calculation error: ${String(error)}`));
+        }
+    });
+}

package/dist/server/utils/index.d.ts

@@ -1,5 +1,7 @@
 export * from "./audio/decoder";
 export * from "./cache";
+export * from "./checksum";
 export * from "./hash";
 export * from "./model-path";
+export * from "./shard-utils";
 //# sourceMappingURL=index.d.ts.map

package/dist/server/utils/index.js

@@ -1,4 +1,6 @@
 export * from "./audio/decoder.js";
 export * from "./cache.js";
+export * from "./checksum.js";
 export * from "./hash.js";
 export * from "./model-path.js";
+export * from "./shard-utils.js";

package/dist/server/utils/shard-utils.d.ts

@@ -0,0 +1,22 @@
+export interface ShardInfo {
+    isSharded: boolean;
+    currentShard?: number;
+    totalShards?: number;
+    baseFilename?: string;
+    extension?: string;
+}
+export interface ShardMetadata {
+    filename: string;
+    expectedSize: number;
+    sha256Checksum: string;
+}
+/**
+ * Detect if model filename follows shard pattern (00001-of-0000x)
+ */
+export declare function detectShardedModel(filename: string): ShardInfo;
+/**
+ * Generate list of all required files for a sharded model
+ * Includes numbered shards AND the .tensors.txt companion file
+ */
+export declare function generateShardFilenames(firstShardName: string): string[];
+//# sourceMappingURL=shard-utils.d.ts.map

package/dist/server/utils/shard-utils.js

@@ -0,0 +1,37 @@
+import { ModelLoadFailedError } from "../../utils/errors-server.js";
+/**
+ * Detect if model filename follows shard pattern (00001-of-0000x)
+ */
+export function detectShardedModel(filename) {
+    const shardPattern = /^(.+)-(\d{5})-of-(\d{5})(\.\w+)$/;
+    const match = filename.match(shardPattern);
+    if (match && match[1] && match[2] && match[3] && match[4]) {
+        return {
+            isSharded: true,
+            baseFilename: match[1],
+            currentShard: parseInt(match[2], 10),
+            totalShards: parseInt(match[3], 10),
+            extension: match[4],
+        };
+    }
+    return { isSharded: false };
+}
+/**
+ * Generate list of all required files for a sharded model
+ * Includes numbered shards AND the .tensors.txt companion file
+ */
+export function generateShardFilenames(firstShardName) {
+    const shardInfo = detectShardedModel(firstShardName);
+    if (!shardInfo.isSharded || !shardInfo.totalShards) {
+        throw new ModelLoadFailedError(`Not a sharded model filename: ${firstShardName}`);
+    }
+    const filenames = [];
+    const { baseFilename, totalShards, extension } = shardInfo;
+    for (let i = 1; i <= totalShards; i++) {
+        const shardNumber = i.toString().padStart(5, "0");
+        const totalShardsStr = totalShards.toString().padStart(5, "0");
+        filenames.push(`${baseFilename}-${shardNumber}-of-${totalShardsStr}${extension}`);
+    }
+    filenames.push(`${baseFilename}.tensors.txt`);
+    return filenames;
+}

package/dist/server/utils/tool-integration.d.ts

@@ -0,0 +1,13 @@
+import type { Tool, ToolCallEvent } from "../../schemas/index";
+interface HistoryMessage {
+    role: string;
+    content: string;
+    attachments?: {
+        path: string;
+    }[] | undefined;
+}
+export declare function insertToolsIntoHistory(history: HistoryMessage[], tools: Tool[]): Array<HistoryMessage | Tool>;
+export declare function setupToolGrammar(modelConfig: Record<string, unknown>, tools: Tool[]): void;
+export declare function checkForToolEvents(accumulatedText: string, currentToken: string, tools: Tool[], emittedToolCallPositions: Set<number>): ToolCallEvent[];
+export {};
+//# sourceMappingURL=tool-integration.d.ts.map

package/dist/server/utils/tool-integration.js

@@ -0,0 +1,43 @@
+import { parseToolCalls, convertToolsToGrammar, } from "./tool-parser.js";
+export function insertToolsIntoHistory(history, tools) {
+    const systemMsgIndex = history.findIndex((msg) => msg.role === "system");
+    if (systemMsgIndex >= 0) {
+        return [
+            ...history.slice(0, systemMsgIndex + 1),
+            ...tools,
+            ...history.slice(systemMsgIndex + 1),
+        ];
+    }
+    return [...tools, ...history];
+}
+export function setupToolGrammar(modelConfig, tools) {
+    const grammar = convertToolsToGrammar(tools);
+    modelConfig["grammar"] = grammar;
+}
+export function checkForToolEvents(accumulatedText, currentToken, tools, emittedToolCallPositions) {
+    const events = [];
+    if (currentToken.includes("</tool_call>") || currentToken.includes("}")) {
+        const { toolCalls, errors } = parseToolCalls(accumulatedText, tools);
+        for (const call of toolCalls) {
+            const callPosition = accumulatedText.indexOf(call.raw || "");
+            if (callPosition >= 0 && !emittedToolCallPositions.has(callPosition)) {
+                emittedToolCallPositions.add(callPosition);
+                events.push({
+                    type: "toolCall",
+                    call,
+                });
+            }
+        }
+        for (const error of errors) {
+            const errorPosition = accumulatedText.indexOf(error.raw || "");
+            if (errorPosition >= 0 && !emittedToolCallPositions.has(errorPosition)) {
+                emittedToolCallPositions.add(errorPosition);
+                events.push({
+                    type: "toolCallError",
+                    error,
+                });
+            }
+        }
+    }
+    return events;
+}

package/dist/server/utils/tool-parser.d.ts

@@ -0,0 +1,7 @@
+import type { Tool, ToolCall, ToolCallError } from "../../schemas/index";
+export declare function parseToolCalls(text: string, tools: Tool[]): {
+    toolCalls: ToolCall[];
+    errors: ToolCallError[];
+};
+export declare function convertToolsToGrammar(tools: Tool[]): string;
+//# sourceMappingURL=tool-parser.d.ts.map