@qvac/sdk 0.9.2 → 0.10.1

package/dist/server/bare/ops/transcribe.js

@@ -5,6 +5,8 @@ import { getServerLogger } from "../../../logging/index.js";
 import { TranscriptionFailedError } from "../../../utils/errors-server.js";
 import { nowMs } from "../../../profiling/index.js";
 import { buildStreamResult } from "../../../profiling/model-execution.js";
+import { assertMetadataSupported, toTranscribeSegment, } from "../utils/transcribe-metadata.js";
+export { assertMetadataSupported, toTranscribeSegment, };
 const logger = getServerLogger();
 function hasRunStreaming(model) {
     return "runStreaming" in model && typeof model.runStreaming === "function";
@@ -15,7 +17,9 @@ const SILENCE_MARKERS = {
 };
 function getEngineModelType(modelId) {
     const entry = getModelEntry(modelId);
-    return entry?.local?.modelType ?? "";
+    if (!entry || entry.isDelegated)
+        return "";
+    return entry.local.modelType;
 }
 function getAudioFormat(modelId, engineType) {
     if (engineType === ModelType.whispercppTranscription) {
@@ -53,8 +57,9 @@ async function restorePrompt(modelId, originalConfig) {
     });
 }
 export async function* transcribe(params) {
-    const { modelId } = params;
+    const { modelId, metadata } = params;
     const engineType = getEngineModelType(modelId);
+    assertMetadataSupported(modelId, engineType, metadata);
     const silenceMarker = SILENCE_MARKERS[engineType] ?? "";
     const audioFormat = getAudioFormat(modelId, engineType);
     const originalConfig = await applyPrompt(modelId, params.prompt, engineType);
@@ -67,7 +72,18 @@ export async function* transcribe(params) {
         response = (await model.run(audioStream));
         for await (const output of response.iterate()) {
             logger.debug("Streaming Transcription Update:", output);
-            const text = output
+            const chunks = output;
+            if (metadata) {
+                for (const chunk of chunks) {
+                    if (!chunk.text)
+                        continue;
+                    if (silenceMarker && chunk.text.includes(silenceMarker))
+                        continue;
+                    yield toTranscribeSegment(chunk);
+                }
+                continue;
+            }
+            const text = chunks
                 .filter((chunk) => !silenceMarker || !chunk.text.includes(silenceMarker))
                 .map((chunk) => chunk.text)
                 .join("");
@@ -96,8 +112,9 @@ export async function* transcribe(params) {
     };
     return buildStreamResult(modelExecutionMs, stats);
 }
-export async function* transcribeStream(modelId, audioInputStream, prompt) {
+export async function* transcribeStream(modelId, audioInputStream, prompt, metadata) {
     const engineType = getEngineModelType(modelId);
+    assertMetadataSupported(modelId, engineType, metadata);
     const silenceMarker = SILENCE_MARKERS[engineType] ?? "";
     const originalConfig = await applyPrompt(modelId, prompt, engineType);
     try {
@@ -113,6 +130,10 @@ export async function* transcribeStream(modelId, audioInputStream, prompt) {
                     continue;
                 if (silenceMarker && segment.text.includes(silenceMarker))
                     continue;
+                if (metadata) {
+                    yield toTranscribeSegment(segment);
+                    continue;
+                }
                 if (segment.text.trim()) {
                     yield segment.text;
                 }

package/dist/server/bare/ops/translate.js

@@ -1,8 +1,9 @@
-import { getModel } from "../registry/model-registry.js";
+import { getModelEntry } from "../registry/model-registry.js";
 import { translateServerParamsSchema, normalizeModelType, ModelType, AFRICAN_LANGUAGES_MAP, } from "../../../schemas/index.js";
 import { getLangName } from "@qvac/langdetect-text";
 import { nowMs } from "../../../profiling/index.js";
 import { buildStreamResult } from "../../../profiling/model-execution.js";
+import { ModelIsDelegatedError, ModelNotFoundError, ModelTypeMismatchError, } from "../../../utils/errors-server.js";
 export function getLanguage(code) {
     if (!code)
         return "";
@@ -14,16 +15,40 @@ export function getLanguage(code) {
 export function isAfrican(code) {
     return !!code && AFRICAN_LANGUAGES_MAP.has(code);
 }
+const LLM_TRANSLATE_GENERATION_PARAMS = {
+    temp: 0,
+    top_k: 1,
+    top_p: 1,
+    repeat_penalty: 1.3,
+    seed: 42,
+    predict: 256,
+};
+function shouldSkipPerCallSampling(modelName) {
+    return !!modelName && modelName.startsWith("AFRICAN_");
+}
 export async function* translate(params) {
     const { modelId, text, modelType: inputModelType } = params;
-    const canonicalModelType = normalizeModelType(inputModelType);
+    const entry = getModelEntry(modelId);
+    if (!entry) {
+        throw new ModelNotFoundError(modelId);
+    }
+    if (entry.isDelegated) {
+        throw new ModelIsDelegatedError(modelId);
+    }
+    const canonicalModelType = entry.local.modelType;
+    const model = entry.local.model;
+    if (inputModelType !== undefined) {
+        const requestedCanonical = normalizeModelType(inputModelType);
+        if (requestedCanonical !== canonicalModelType) {
+            throw new ModelTypeMismatchError(canonicalModelType, requestedCanonical);
+        }
+    }
     const isLlm = canonicalModelType === ModelType.llamacppCompletion;
     const from = isLlm ? params.from : undefined;
     const to = isLlm ? params.to : undefined;
     const context = isLlm ? params.context : undefined;
     const afriquePrompt = isLlm && (isAfrican(from) || isAfrican(to));
     translateServerParamsSchema.parse(params);
-    const model = getModel(modelId);
     const fromLanguage = getLanguage(from);
     const toLanguage = getLanguage(to);
     // Check if input is an array and model type is NMT
@@ -57,7 +82,20 @@ export async function* translate(params) {
             },
         ];
     const modelStart = nowMs();
-    const response = await model.run(input);
+    let response;
+    if (canonicalModelType === ModelType.llamacppCompletion &&
+        !shouldSkipPerCallSampling(entry.local.name)) {
+        // AnyModel.run is intentionally erased to a single-arg signature in the
+        // registry layer (Omit<BaseInference, "addon">). Re-narrow to the engine
+        // shape so we get the same typing as @qvac/llm-llamacpp.run().
+        const llmRun = model.run.bind(model);
+        response = await llmRun(input, {
+            generationParams: LLM_TRANSLATE_GENERATION_PARAMS,
+        });
+    }
+    else {
+        response = await model.run(input);
+    }
     // Check if the response has an iterate method (like LLM models)
     if (canonicalModelType === ModelType.llamacppCompletion &&
         typeof response.iterate === "function") {

package/dist/server/bare/ops/unload-model.js

@@ -7,6 +7,7 @@ import { unregisterAddonLogger, getServerLogger } from "../../../logging/index.j
 import { unloadModelParamsSchema } from "../../../schemas/index.js";
 import { ModelNotLoadedError } from "../../../utils/errors-server.js";
 import { detectShardedModel } from "../../utils/index.js";
+import { getClearStorageTarget } from "../../utils/cache/paths.js";
 const logger = getServerLogger();
 export async function unloadModel(params) {
     const { modelId, clearStorage } = unloadModelParamsSchema.parse(params);
@@ -15,26 +16,27 @@ export async function unloadModel(params) {
         throw new ModelNotLoadedError(modelId);
     }
     clearFinetuneRuntimeState(modelId);
-    if (entry.local?.loader) {
-        await entry.local.loader.close();
-    }
-    if (entry.local?.model && entry.local.model.unload) {
-        await entry.local.model.unload();
-    }
-    if (clearStorage && entry.local?.path) {
-        const modelPath = entry.local.path;
-        const modelFileName = path.basename(modelPath);
-        const shardInfo = detectShardedModel(modelFileName);
-        if (shardInfo.isSharded) {
-            // Delete entire shard directory
-            const shardDir = path.dirname(modelPath);
-            await fsPromises.rm(shardDir, { recursive: true, force: true });
-            logger.info(`Sharded model storage cleared: ${shardDir}`);
+    if (!entry.isDelegated) {
+        if (entry.local.model.unload) {
+            await entry.local.model.unload();
         }
-        else {
-            // Delete single file
-            await fsPromises.rm(modelPath, { recursive: true, force: true });
-            logger.info(`Model storage cleared: ${modelPath}`);
+        if (clearStorage && entry.local.path) {
+            const modelPath = entry.local.path;
+            const modelFileName = path.basename(modelPath);
+            const shardInfo = detectShardedModel(modelFileName);
+            if (shardInfo.isSharded) {
+                const shardDir = path.dirname(modelPath);
+                await fsPromises.rm(shardDir, { recursive: true, force: true });
+                logger.info(`Sharded model storage cleared: ${shardDir}`);
+            }
+            else {
+                const target = getClearStorageTarget(modelPath);
+                await fsPromises.rm(target.path, {
+                    recursive: target.kind === "directory",
+                    force: true,
+                });
+                logger.info(`Model storage cleared (${target.kind}): ${target.path}`);
+            }
         }
     }
     unregisterAddonLogger(modelId);

package/dist/server/bare/plugins/llamacpp-completion/ops/cache-logger.js

@@ -23,8 +23,7 @@ export function logCacheInit(cacheKey, systemPrompt, toolCount) {
 }
 export function logMessagesToAddon(messages, phase = "PROMPT_SEND") {
     const typedMessages = messages;
-    const nonSessionMsgs = typedMessages.filter((m) => m.role !== "session");
-    logger.debug(`[kv-cache] [${phase}] Sending ${nonSessionMsgs.length} msg(s): [${formatMessages(nonSessionMsgs)}]`);
+    logger.debug(`[kv-cache] [${phase}] Sending ${typedMessages.length} msg(s): [${formatMessages(typedMessages)}]`);
 }
 export function logCacheDisabled() {
     logger.debug("[kv-cache] Cache disabled");

package/dist/server/bare/plugins/llamacpp-completion/ops/completion-stream.d.ts

@@ -1,14 +1,19 @@
-import type { CompletionParams, CompletionStats, GenerationParams, Tool, ToolCall, ToolCallEvent } from "../../../../../schemas/index";
-export declare function clearCachedMessageCounts(cachePath?: string): void;
+import type { CompletionParams, CompletionStats, GenerationParams, ResponseFormat, Tool, ToolCall, ToolDialect } from "../../../../../schemas/index";
+import { noteCancelRequested as noteCancelRequestedFromState } from "./kv-cache-state";
+interface CompletionResult {
+    modelExecutionMs: number;
+    stats?: CompletionStats;
+    toolCalls: ToolCall[];
+}
+export declare function clearCachedMessageCounts(prefix?: string): void;
+export declare const noteCancelRequested: typeof noteCancelRequestedFromState;
 export declare function completion(params: CompletionParams & {
     tools?: Tool[];
     generationParams?: GenerationParams;
+    toolDialect?: ToolDialect;
+    responseFormat?: ResponseFormat;
 }): AsyncGenerator<{
     token: string;
-    toolCallEvent?: ToolCallEvent;
-}, {
-    modelExecutionMs: number;
-    stats?: CompletionStats;
-    toolCalls: ToolCall[];
-}, unknown>;
+}, CompletionResult, unknown>;
+export {};
 //# sourceMappingURL=completion-stream.d.ts.map