@qvac/sdk 0.17.1 → 0.18.1

package/dist/server/bare/plugins/audiogen-ggml/ops/audio-gen-input.js

@@ -0,0 +1,153 @@
+import fs from 'bare-fs';
+import { AUDIOGEN_INPUT_CHANNELS, AUDIOGEN_INPUT_MAX_SECONDS, AUDIOGEN_INPUT_SAMPLE_RATE } from '../../../../../schemas/audio-gen.js';
+import { decodeAudioToStream, needsDecoding } from '../../../../../server/utils/audio/decoder.js';
+import { AudioFileNotFoundError, InvalidAudioInputError } from '../../../../../utils/errors-server.js';
+const FLOAT32_BYTES = Float32Array.BYTES_PER_ELEMENT;
+const STEREO_FRAME_BYTES = FLOAT32_BYTES * AUDIOGEN_INPUT_CHANNELS;
+/** Upper bound for raw stereo input bytes (base64 payloads and raw PCM files). */
+const MAX_STEREO_BYTES = AUDIOGEN_INPUT_MAX_SECONDS * AUDIOGEN_INPUT_SAMPLE_RATE * STEREO_FRAME_BYTES;
+/** Upper bound for the mono float stream the FFmpeg decoder may emit. */
+const MAX_DECODED_MONO_BYTES = AUDIOGEN_INPUT_MAX_SECONDS * AUDIOGEN_INPUT_SAMPLE_RATE * FLOAT32_BYTES;
+/**
+ * Resolve a reference/source audio input into the interleaved stereo 48 kHz
+ * Float32 PCM the ACE-Step engine consumes.
+ *
+ * - `base64` inputs (client `Buffer`/`Uint8Array`) must already be raw
+ *   interleaved stereo 48 kHz Float32 LE PCM; they are handed over as-is
+ *   (a copy is made only when the bytes are not 4-byte aligned).
+ * - `filePath` inputs with a decodable extension (`.wav`, `.mp3`, `.m4a`,
+ *   `.ogg`, `.flac`, `.aac`) are decoded through the SDK's FFmpeg decoder to
+ *   48 kHz mono float PCM and duplicated onto both channels. Any other
+ *   extension is streamed in as raw interleaved stereo 48 kHz Float32 LE PCM.
+ *
+ * Every path is bounded by `AUDIOGEN_INPUT_MAX_SECONDS` and rejects
+ * non-finite samples, so malformed or oversized input fails with
+ * `InvalidAudioInputError` before the engine is invoked.
+ */
+export async function resolveAudioGenPcm(input, name) {
+    switch (input.type) {
+        case 'base64':
+            return toStereoFloat32(Buffer.from(input.value, 'base64'), name);
+        case 'filePath': {
+            const filePath = input.value;
+            if (!needsDecoding(filePath)) {
+                return toStereoFloat32(await readRawPcmFile(filePath, name), name);
+            }
+            await assertDecodableFileSize(filePath, name);
+            return monoToStereo(await decodeMonoFloat32(filePath, name), name);
+        }
+        default:
+            throw new InvalidAudioInputError(`${name} must be a file path or raw PCM bytes`);
+    }
+}
+async function statInput(filePath) {
+    try {
+        return await fs.promises.stat(filePath);
+    }
+    catch (error) {
+        throw new AudioFileNotFoundError(filePath, error);
+    }
+}
+/**
+ * The FFmpeg decoder buffers the whole input file before emitting PCM, so the
+ * file itself is bounded up front: no encoded container for a clip within
+ * `AUDIOGEN_INPUT_MAX_SECONDS` exceeds the size of that clip as raw stereo
+ * Float32 PCM.
+ */
+async function assertDecodableFileSize(filePath, name) {
+    const stats = await statInput(filePath);
+    if (stats.size <= MAX_STEREO_BYTES)
+        return;
+    throw new InvalidAudioInputError(`${name} (${filePath}) is ${Math.round(stats.size / 1_000_000)} MB; ` +
+        `files over ${Math.round(MAX_STEREO_BYTES / 1_000_000)} MB cannot fit the ` +
+        `${AUDIOGEN_INPUT_MAX_SECONDS} s limit and are rejected before decoding`);
+}
+/** Stream a raw PCM file into memory without blocking the event loop, capped by size. */
+async function readRawPcmFile(filePath, name) {
+    const stats = await statInput(filePath);
+    assertWithinLimit(stats.size, MAX_STEREO_BYTES, STEREO_FRAME_BYTES, name, filePath);
+    const chunks = [];
+    let total = 0;
+    const stream = fs.createReadStream(filePath);
+    for await (const chunk of stream) {
+        total += chunk.byteLength;
+        assertWithinLimit(total, MAX_STEREO_BYTES, STEREO_FRAME_BYTES, name, filePath);
+        chunks.push(chunk);
+    }
+    return chunks.length === 1 ? chunks[0] : Buffer.concat(chunks, total);
+}
+async function decodeMonoFloat32(filePath, name) {
+    const chunks = [];
+    let total = 0;
+    try {
+        const stream = await decodeAudioToStream(filePath, 'f32le', {
+            sampleRate: AUDIOGEN_INPUT_SAMPLE_RATE
+        });
+        for await (const chunk of stream) {
+            total += chunk.byteLength;
+            if (total > MAX_DECODED_MONO_BYTES) {
+                ;
+                stream.destroy();
+                assertWithinLimit(total, MAX_DECODED_MONO_BYTES, FLOAT32_BYTES, name, filePath);
+            }
+            chunks.push(chunk);
+        }
+    }
+    catch (error) {
+        if (error instanceof InvalidAudioInputError)
+            throw error;
+        throw new InvalidAudioInputError(`${name} could not be decoded from ${filePath}`, error);
+    }
+    if (total === 0 || total % FLOAT32_BYTES !== 0) {
+        throw new InvalidAudioInputError(`${name} decoded to no usable audio from ${filePath}`);
+    }
+    return asFloat32(chunks.length === 1 ? chunks[0] : Buffer.concat(chunks, total));
+}
+function monoToStereo(mono, name) {
+    if (mono.length === 0) {
+        throw new InvalidAudioInputError(`${name} decoded to no usable audio`);
+    }
+    const stereo = new Float32Array(mono.length * AUDIOGEN_INPUT_CHANNELS);
+    for (let frame = 0; frame < mono.length; frame++) {
+        const sample = mono[frame];
+        if (!Number.isFinite(sample))
+            throw nonFiniteError(name);
+        stereo[frame * AUDIOGEN_INPUT_CHANNELS] = sample;
+        stereo[frame * AUDIOGEN_INPUT_CHANNELS + 1] = sample;
+    }
+    return stereo;
+}
+function toStereoFloat32(bytes, name) {
+    if (bytes.byteLength === 0 || bytes.byteLength % STEREO_FRAME_BYTES !== 0) {
+        throw new InvalidAudioInputError(`${name} must be non-empty interleaved stereo ${AUDIOGEN_INPUT_SAMPLE_RATE} Hz Float32 PCM ` +
+            `(byte length a multiple of ${STEREO_FRAME_BYTES}, got ${bytes.byteLength})`);
+    }
+    assertWithinLimit(bytes.byteLength, MAX_STEREO_BYTES, STEREO_FRAME_BYTES, name);
+    const pcm = asFloat32(bytes);
+    for (let index = 0; index < pcm.length; index++) {
+        if (!Number.isFinite(pcm[index]))
+            throw nonFiniteError(name);
+    }
+    return pcm;
+}
+/**
+ * View the bytes as Float32 without copying when they are 4-byte aligned
+ * (fresh Buffers from base64/file reads and `Buffer.concat` are); only a
+ * misaligned pooled slice needs to be copied out.
+ */
+function asFloat32(bytes) {
+    if (bytes.byteOffset % FLOAT32_BYTES === 0) {
+        return new Float32Array(bytes.buffer, bytes.byteOffset, bytes.byteLength / FLOAT32_BYTES);
+    }
+    return new Float32Array(bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength));
+}
+function assertWithinLimit(bytes, limit, frameBytes, name, filePath) {
+    if (bytes <= limit)
+        return;
+    const seconds = Math.round(bytes / frameBytes / AUDIOGEN_INPUT_SAMPLE_RATE);
+    throw new InvalidAudioInputError(`${name}${filePath ? ` (${filePath})` : ''} is about ${seconds} s long; ` +
+        `the limit is ${AUDIOGEN_INPUT_MAX_SECONDS} s`);
+}
+function nonFiniteError(name) {
+    return new InvalidAudioInputError(`${name} must contain only finite samples`);
+}

package/dist/server/bare/plugins/audiogen-ggml/ops/audio-gen-stream.js

@@ -53,6 +53,7 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
 import { AudioGen } from '@qvac/audiogen-ggml';
 import { audioGenStatsSchema } from '../../../../../schemas/audio-gen.js';
 import { getServerLogger } from '../../../../../logging/index.js';
+import { resolveAudioGenPcm } from '../../../../../server/bare/plugins/audiogen-ggml/ops/audio-gen-input.js';
 import { getModel } from '../../../../../server/bare/registry/model-registry.js';
 import { getRequestRegistry, withRequestContext } from '../../../../../server/bare/runtime/index.js';
 import { generateServerRequestId } from '../../../../../server/bare/runtime/request-id.js';
@@ -97,6 +98,14 @@ export async function* audioGenStream(request) {
         });
         let response;
         try {
+            // Reference/source audio is decoded before the run is admitted so the
+            // model slot is never held by a request that fails on input decoding.
+            // Decoding can take real time, so the abort state is re-checked after it:
+            // an abort that fired mid-decode found no active native job to cancel, and
+            // starting the run afterwards would leave a ghost generation on the slot.
+            const { referenceAudio, sourceAudio } = ctx.signal.aborted
+                ? {}
+                : await resolveAudioInputs(request, logger);
             if (!ctx.signal.aborted) {
                 response = await model.run(request.caption, {
                     ...(request.lyrics !== undefined && { lyrics: request.lyrics }),
@@ -105,7 +114,24 @@ export async function* audioGenStream(request) {
                     ...(request.bpm !== undefined && { bpm: request.bpm }),
                     ...(request.keyscale !== undefined && { keyscale: request.keyscale }),
                     ...(request.timesignature !== undefined && { timesignature: request.timesignature }),
-                    ...(request.duration !== undefined && { duration: request.duration })
+                    ...(request.duration !== undefined && { duration: request.duration }),
+                    ...(request.lmTemperature !== undefined && { lmTemperature: request.lmTemperature }),
+                    ...(request.lmTopP !== undefined && { lmTopP: request.lmTopP }),
+                    ...(request.lmTopK !== undefined && { lmTopK: request.lmTopK }),
+                    ...(request.lmCfgScale !== undefined && { lmCfgScale: request.lmCfgScale }),
+                    ...(request.lmPhase1 !== undefined && { lmPhase1: request.lmPhase1 }),
+                    ...(request.dcwEnabled !== undefined && { dcwEnabled: request.dcwEnabled }),
+                    ...(request.dcwScaler !== undefined && { dcwScaler: request.dcwScaler }),
+                    ...(request.dcwHighScaler !== undefined && { dcwHighScaler: request.dcwHighScaler }),
+                    ...(request.taskType !== undefined && { taskType: request.taskType }),
+                    ...(request.audioCoverStrength !== undefined && {
+                        audioCoverStrength: request.audioCoverStrength
+                    }),
+                    ...(request.coverNoiseStrength !== undefined && {
+                        coverNoiseStrength: request.coverNoiseStrength
+                    }),
+                    ...(referenceAudio && { referenceAudio }),
+                    ...(sourceAudio && { sourceAudio })
                 });
                 for await (const chunk of response.iterate()) {
                     if (ctx.signal.aborted)
@@ -160,3 +186,28 @@ export async function* audioGenStream(request) {
             await result_1;
     }
 }
+/**
+ * Decode both optional audio inputs concurrently. When both fail, the first
+ * failure is thrown and the second is logged so neither diagnostic is lost.
+ */
+async function resolveAudioInputs(request, logger) {
+    const [reference, source] = await Promise.allSettled([
+        request.referenceAudio
+            ? resolveAudioGenPcm(request.referenceAudio, 'referenceAudio')
+            : Promise.resolve(undefined),
+        request.sourceAudio
+            ? resolveAudioGenPcm(request.sourceAudio, 'sourceAudio')
+            : Promise.resolve(undefined)
+    ]);
+    const failures = [reference, source].filter((result) => result.status === 'rejected');
+    if (failures.length > 0) {
+        for (const extra of failures.slice(1)) {
+            logger.warn(`[audiogen] additional audio input failure for modelId=${request.modelId}: ${extra.reason instanceof Error ? extra.reason.message : String(extra.reason)}`);
+        }
+        throw failures[0].reason;
+    }
+    return {
+        referenceAudio: reference.status === 'fulfilled' ? reference.value : undefined,
+        sourceAudio: source.status === 'fulfilled' ? source.value : undefined
+    };
+}

package/dist/server/bare/plugins/audiogen-ggml/plugin.d.ts

@@ -175,6 +175,20 @@ export declare const audioGenPlugin: {
         audioGenStream: import("../../../../schemas/index.js").PluginHandlerDefinition<import("zod").ZodObject<{
             type: import("zod").ZodLiteral<"audioGenStream">;
             requestId: import("zod").ZodOptional<import("zod").ZodString>;
+            referenceAudio: import("zod").ZodOptional<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                type: import("zod").ZodLiteral<"base64">;
+                value: import("zod").ZodString;
+            }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                type: import("zod").ZodLiteral<"filePath">;
+                value: import("zod").ZodString;
+            }, import("zod/v4/core").$strip>], "type">>;
+            sourceAudio: import("zod").ZodOptional<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                type: import("zod").ZodLiteral<"base64">;
+                value: import("zod").ZodString;
+            }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                type: import("zod").ZodLiteral<"filePath">;
+                value: import("zod").ZodString;
+            }, import("zod/v4/core").$strip>], "type">>;
             modelId: import("zod").ZodString;
             caption: import("zod").ZodString;
             lyrics: import("zod").ZodOptional<import("zod").ZodString>;
@@ -184,6 +198,20 @@ export declare const audioGenPlugin: {
             keyscale: import("zod").ZodOptional<import("zod").ZodString>;
             timesignature: import("zod").ZodOptional<import("zod").ZodString>;
             duration: import("zod").ZodOptional<import("zod").ZodNumber>;
+            lmTemperature: import("zod").ZodOptional<import("zod").ZodNumber>;
+            lmTopP: import("zod").ZodOptional<import("zod").ZodNumber>;
+            lmTopK: import("zod").ZodOptional<import("zod").ZodNumber>;
+            lmCfgScale: import("zod").ZodOptional<import("zod").ZodNumber>;
+            lmPhase1: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            dcwEnabled: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            dcwScaler: import("zod").ZodOptional<import("zod").ZodNumber>;
+            dcwHighScaler: import("zod").ZodOptional<import("zod").ZodNumber>;
+            taskType: import("zod").ZodOptional<import("zod").ZodEnum<{
+                text2music: "text2music";
+                "cover-nofsq": "cover-nofsq";
+            }>>;
+            audioCoverStrength: import("zod").ZodOptional<import("zod").ZodNumber>;
+            coverNoiseStrength: import("zod").ZodOptional<import("zod").ZodNumber>;
         }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
             type: import("zod").ZodLiteral<"audioGenStream">;
             progress: import("zod").ZodOptional<import("zod").ZodObject<{

package/dist/server/bare/plugins/ggml-ocr/plugin.js

@@ -12,7 +12,9 @@ function createOCRModel(modelId, detectorPath, recognizerPath, ocrConfig) {
     const params = {
         pathDetector: detectorPath,
         pathRecognizer: recognizerPath,
-        langList: ocrConfig.langList || ['en'],
+        ...(ocrConfig.langList !== undefined
+            ? { langList: ocrConfig.langList }
+            : ocrConfig.pipelineType !== 'doctr' && { langList: ['en'] }),
         ...(ocrConfig.pipelineType !== undefined && {
             pipelineType: ocrConfig.pipelineType
         }),

package/dist/server/bare/plugins/ggml-vla/ops/vla-set-embodiment.d.ts

@@ -0,0 +1,3 @@
+import { type VlaSetEmbodimentRequest, type VlaSetEmbodimentResponse } from '../../../../../schemas/index.js';
+export declare function vlaSetEmbodiment(request: VlaSetEmbodimentRequest): Promise<VlaSetEmbodimentResponse>;
+//# sourceMappingURL=vla-set-embodiment.d.ts.map

package/dist/server/bare/plugins/ggml-vla/ops/vla-set-embodiment.js

@@ -0,0 +1,9 @@
+import { getModel } from '../../../../../server/bare/registry/model-registry.js';
+import { vlaHparamsSchema } from '../../../../../schemas/index.js';
+export async function vlaSetEmbodiment(request) {
+    const model = getModel(request.modelId);
+    const hparams = await model.setEmbodiment(request.embodiment);
+    // Validate the addon-reported hparams against our schema so the wire
+    // shape stays consistent even if the underlying addon changes.
+    return { hparams: vlaHparamsSchema.parse(hparams) };
+}

package/dist/server/bare/plugins/ggml-vla/plugin.d.ts

@@ -9,6 +9,11 @@ export declare const vlaPlugin: {
             auto: "auto";
         }>>;
         verbosity: import("zod").ZodOptional<import("zod").ZodNumber>;
+        embodiment: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodObject<{
+            tag: import("zod").ZodOptional<import("zod").ZodString>;
+            catId: import("zod").ZodOptional<import("zod").ZodNumber>;
+            numCameras: import("zod").ZodOptional<import("zod").ZodNumber>;
+        }, import("zod/v4/core").$strip>]>>;
     }, import("zod/v4/core").$strip>;
     createModel(params: CreateModelParams): PluginModelResult;
     handlers: {
@@ -58,9 +63,41 @@ export declare const vlaPlugin: {
                     patches: "patches";
                 }>>;
                 imagePatchElems: import("zod").ZodOptional<import("zod").ZodNumber>;
+                selectedEmbodimentTag: import("zod").ZodOptional<import("zod").ZodString>;
+                selectedEmbodimentCatId: import("zod").ZodOptional<import("zod").ZodNumber>;
             }, import("zod/v4/core").$strip>;
             backendName: import("zod").ZodNullable<import("zod").ZodString>;
         }, import("zod/v4/core").$strip>>;
+        vlaSetEmbodiment: import("../../../../schemas/index.js").PluginHandlerDefinition<import("zod").ZodObject<{
+            type: import("zod").ZodLiteral<"vlaSetEmbodiment">;
+            modelId: import("zod").ZodString;
+            embodiment: import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodObject<{
+                tag: import("zod").ZodOptional<import("zod").ZodString>;
+                catId: import("zod").ZodOptional<import("zod").ZodNumber>;
+                numCameras: import("zod").ZodOptional<import("zod").ZodNumber>;
+            }, import("zod/v4/core").$strip>]>;
+        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+            hparams: import("zod").ZodObject<{
+                chunkSize: import("zod").ZodNumber;
+                actionDim: import("zod").ZodNumber;
+                maxActionDim: import("zod").ZodNumber;
+                maxStateDim: import("zod").ZodNumber;
+                tokenizerMaxLength: import("zod").ZodNumber;
+                visionImageSize: import("zod").ZodNumber;
+                numCameras: import("zod").ZodOptional<import("zod").ZodNumber>;
+                stateInputMode: import("zod").ZodOptional<import("zod").ZodEnum<{
+                    discrete: "discrete";
+                    continuous: "continuous";
+                }>>;
+                imageInputMode: import("zod").ZodOptional<import("zod").ZodEnum<{
+                    pixels: "pixels";
+                    patches: "patches";
+                }>>;
+                imagePatchElems: import("zod").ZodOptional<import("zod").ZodNumber>;
+                selectedEmbodimentTag: import("zod").ZodOptional<import("zod").ZodString>;
+                selectedEmbodimentCatId: import("zod").ZodOptional<import("zod").ZodNumber>;
+            }, import("zod/v4/core").$strip>;
+        }, import("zod/v4/core").$strip>>;
     };
 };
 //# sourceMappingURL=plugin.d.ts.map

package/dist/server/bare/plugins/ggml-vla/plugin.js

@@ -1,8 +1,9 @@
 import { VlaModel } from '@qvac/vla-ggml';
-import { definePlugin, defineHandler, vlaConfigSchema, vlaRunRequestSchema, vlaRunResponseSchema, vlaHparamsRequestSchema, vlaHparamsResponseSchema, ModelType, ADDON_VLA } from '../../../../schemas/index.js';
+import { definePlugin, defineHandler, vlaConfigSchema, vlaRunRequestSchema, vlaRunResponseSchema, vlaHparamsRequestSchema, vlaHparamsResponseSchema, vlaSetEmbodimentRequestSchema, vlaSetEmbodimentResponseSchema, ModelType, ADDON_VLA } from '../../../../schemas/index.js';
 import { createStreamLogger, registerAddonLogger } from '../../../../logging/index.js';
 import { vlaRun } from './ops/vla-run.js';
 import { vlaGetHparams } from './ops/vla-hparams.js';
+import { vlaSetEmbodiment } from './ops/vla-set-embodiment.js';
 // The `@qvac/vla-ggml` VlaModel exposes `load({ backend })` rather than the
 // `load(force?)` signature `PluginModel` expects. Wrap it so the plugin
 // framework can call `load()` and have the configured backend flow through.
@@ -23,11 +24,18 @@ export const vlaPlugin = definePlugin({
         const config = (params.modelConfig ?? {});
         const logger = createStreamLogger(params.modelId, ModelType.ggmlVla);
         registerAddonLogger(params.modelId, ModelType.ggmlVla, logger);
+        const addonConfig = {
+            ...(config.verbosity !== undefined && { verbosity: config.verbosity }),
+            // The zod-inferred selector widens optional props with `| undefined`,
+            // which exactOptionalPropertyTypes rejects against the addon's exact
+            // shape — the runtime value is identical, so re-assert the addon type.
+            ...(config.embodiment !== undefined && {
+                embodiment: config.embodiment
+            })
+        };
         const inner = new VlaModel({
             files: { model: [params.modelPath] },
-            ...(config.verbosity !== undefined && {
-                config: { verbosity: config.verbosity }
-            }),
+            ...(Object.keys(addonConfig).length > 0 && { config: addonConfig }),
             logger,
             opts: { stats: true }
         });
@@ -52,6 +60,15 @@ export const vlaPlugin = definePlugin({
             streaming: false,
             cancel: { scope: 'none' },
             handler: vlaGetHparams
+        }),
+        vlaSetEmbodiment: defineHandler({
+            requestSchema: vlaSetEmbodimentRequestSchema,
+            responseSchema: vlaSetEmbodimentResponseSchema,
+            streaming: false,
+            // The addon refuses to switch while an inference job is in flight
+            // (JOB_ALREADY_RUNNING), so there is nothing meaningful to cancel here.
+            cancel: { scope: 'none' },
+            handler: vlaSetEmbodiment
         })
     }
 });

package/dist/server/bare/plugins/llamacpp-completion/ops/batch-completion-stream.js

@@ -1,4 +1,3 @@
-import { TOOLS_MODE } from '../../../../../schemas/tools.js';
 import { getModel, getModelConfig } from '../../../../../server/bare/registry/model-registry.js';
 import { getServerLogger } from '../../../../../logging/index.js';
 import { nowMs } from '../../../../../profiling/index.js';
@@ -6,7 +5,7 @@ import { buildStreamResult } from '../../../../../profiling/model-execution.js';
 import { getResponseFormatJsonSchema } from '../../../../../server/utils/response-format.js';
 import { transformMessages } from '../../../../../server/bare/plugins/llamacpp-completion/ops/completion-stream.js';
 import { normalizeCompletionStats } from '../../../../../server/bare/plugins/llamacpp-completion/ops/completion-stats.js';
-import { appendToolsToHistory, prependToolsToHistory } from '../../../../../server/utils/tool-integration.js';
+import { prependToolsToHistory } from '../../../../../server/utils/tool-integration.js';
 const logger = getServerLogger();
 function runBatchModel(model, prompts) {
     const run = model.run.bind(model);
@@ -27,10 +26,7 @@ function renderPromptHistory(prompt, options) {
     const tools = options.toolsEnabled && prompt.tools && prompt.tools.length > 0 ? prompt.tools : undefined;
     let historyWithTools = prompt.history;
     if (tools) {
-        historyWithTools =
-            options.toolsMode === TOOLS_MODE.dynamic
-                ? appendToolsToHistory(prompt.history, tools)
-                : prependToolsToHistory(prompt.history, tools);
+        historyWithTools = prependToolsToHistory(prompt.history, tools);
     }
     // Uses the same attachment expansion as single completion: each SDK
     // attachment becomes an addon `type: "media"` message before the text turn.
@@ -61,26 +57,31 @@ export async function* batchCompletion(params, opts) {
     const model = getModel(modelId);
     const modelConfig = getModelConfig(modelId);
     const renderOptions = {
-        toolsEnabled: modelConfig.tools === true,
-        toolsMode: modelConfig.toolsMode
+        toolsEnabled: modelConfig.tools === true
     };
-    const onAbort = () => {
-        const addon = model.addon;
-        if (addon?.cancel) {
-            addon.cancel.call(addon).catch((err) => {
-                requestLogger.warn(`[cancel] addon.cancel() rejected during batch abort for modelId=${modelId}: ${err instanceof Error ? err.message : String(err)}`);
-            });
-        }
+    // Cancel via the batch response, mirroring completion(): the addon routes
+    // response.cancel() to cancelJob for this batch group only, so a concurrent
+    // peer batch or completion on the same model keeps decoding.
+    let activeResponse = null;
+    const cancelActive = () => {
+        activeResponse?.cancel().catch((err) => {
+            requestLogger.warn(`[cancel] batch response.cancel() rejected during abort for modelId=${modelId}: ${err instanceof Error ? err.message : String(err)}`);
+        });
     };
+    const onAbort = () => cancelActive();
     signal.addEventListener('abort', onAbort, { once: true });
     if (signal.aborted)
         onAbort();
     scope.defer(() => {
         signal.removeEventListener('abort', onAbort);
+        activeResponse = null;
     });
     const addonPrompts = prompts.map((prompt) => buildBatchPrompt(prompt, renderOptions));
     const modelStart = nowMs();
     const response = await runBatchModel(model, addonPrompts);
+    activeResponse = response;
+    if (signal.aborted)
+        cancelActive();
     const ids = response.ids;
     yield { type: 'ids', ids };
     for await (const output of response.iterate()) {

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

@@ -1,5 +1,5 @@
 export declare function logCacheStatus(cacheKey: string, isReusing: boolean): void;
-export declare function logCacheInit(cacheKey: string, systemPrompt: string, toolCount: number): void;
+export declare function logCacheInit(cacheKey: string, systemPrompt: string): void;
 export declare function logMessagesToAddon(messages: unknown[], phase?: 'CACHE_INIT' | 'PROMPT_SEND' | 'NO_CACHE'): void;
 export declare function logCacheDisabled(): void;
 export declare function logCacheSave(sessionPath: string): void;

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

@@ -17,9 +17,9 @@ export function logCacheStatus(cacheKey, isReusing) {
     const status = isReusing ? 'REUSING' : 'CREATING';
     logger.debug(`[kv-cache] [${cacheKey}] ${status} cache`);
 }
-export function logCacheInit(cacheKey, systemPrompt, toolCount) {
+export function logCacheInit(cacheKey, systemPrompt) {
     const promptLen = systemPrompt.length;
-    logger.debug(`[kv-cache] [${cacheKey}] Initializing cache (prompt: ${promptLen} chars, tools: ${toolCount})`);
+    logger.debug(`[kv-cache] [${cacheKey}] Initializing cache (prompt: ${promptLen} chars)`);
 }
 export function logMessagesToAddon(messages, phase = 'PROMPT_SEND') {
     const typedMessages = messages;

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

@@ -18,4 +18,10 @@ export declare function normalizeCompletionStats(stats: LlmStats | undefined): {
  * when nothing was streamed.
  */
 export declare function withEmittedTokens(stats: CompletionStats | undefined, emittedPieces: number): CompletionStats | undefined;
+export declare function stoppedByLength({ cancelled, effectivePredict, generatedTokens, stoppedAtContextBoundary }: {
+    cancelled: boolean;
+    effectivePredict: number | undefined;
+    generatedTokens: number | undefined;
+    stoppedAtContextBoundary: boolean;
+}): boolean;
 //# sourceMappingURL=completion-stats.d.ts.map

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

@@ -46,3 +46,13 @@ export function withEmittedTokens(stats, emittedPieces) {
         emittedTokens
     };
 }
+export function stoppedByLength({ cancelled, effectivePredict, generatedTokens, stoppedAtContextBoundary }) {
+    if (cancelled)
+        return false;
+    if (stoppedAtContextBoundary)
+        return true;
+    return (effectivePredict !== undefined &&
+        effectivePredict > 0 &&
+        generatedTokens !== undefined &&
+        generatedTokens >= effectivePredict);
+}

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

@@ -6,6 +6,7 @@ interface CompletionResult {
     modelExecutionMs: number;
     stats?: CompletionStats;
     toolCalls: ToolCall[];
+    stoppedAtContextBoundary: boolean;
 }
 interface ChatHistory {
     role?: string;