@qvac/sdk 0.14.1 → 0.16.0

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

@@ -1,5 +1,5 @@
-import { getModel } from "../../../registry/model-registry.js";
-import { vlaHparamsSchema, } from "../../../../../schemas/index.js";
+import { getModel } from '../../../registry/model-registry.js';
+import { vlaHparamsSchema } from '../../../../../schemas/index.js';
 export function vlaGetHparams(request) {
     const model = getModel(request.modelId);
     // Validate the addon-reported hparams against our schema so the wire
@@ -7,6 +7,6 @@ export function vlaGetHparams(request) {
     const parsed = vlaHparamsSchema.parse(model.hparams);
     return Promise.resolve({
         hparams: parsed,
-        backendName: model.backendName ?? null,
+        backendName: model.backendName ?? null
     });
 }

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

@@ -1,3 +1,3 @@
-import { type VlaRunRequest, type VlaRunResponse } from "../../../../../schemas/index";
+import { type VlaRunRequest, type VlaRunResponse } from '../../../../../schemas/index';
 export declare function vlaRun(request: VlaRunRequest): Promise<VlaRunResponse>;
 //# sourceMappingURL=vla-run.d.ts.map

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

@@ -1,6 +1,6 @@
-import { getModel } from "../../../registry/model-registry.js";
-import {} from "../../../../../schemas/index.js";
-import { decodeBase64, encodeBase64 } from "../../../../../utils/encoding.js";
+import { getModel } from '../../../registry/model-registry.js';
+import {} from '../../../../../schemas/index.js';
+import { decodeBase64, encodeBase64 } from '../../../../../utils/encoding.js';
 function f32FromBase64(b64) {
     const bytes = decodeBase64(b64);
     // ArrayBuffer view must be aligned; copy if needed.
@@ -27,26 +27,26 @@ function f32ToBase64(arr) {
     return encodeBase64(new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength));
 }
 function pickStats(raw) {
-    if (!raw || typeof raw !== "object")
+    if (!raw || typeof raw !== 'object')
         return undefined;
     const r = raw;
     const out = {};
-    if (typeof r["vision_ms"] === "number")
-        out.vision_ms = r["vision_ms"];
-    if (typeof r["prefill_compute_ms"] === "number")
-        out.prefill_compute_ms = r["prefill_compute_ms"];
-    if (typeof r["prefill_total_ms"] === "number")
-        out.prefill_total_ms = r["prefill_total_ms"];
-    if (typeof r["smollm2_compute_ms"] === "number")
-        out.smollm2_compute_ms = r["smollm2_compute_ms"];
-    if (typeof r["smollm2_total_ms"] === "number")
-        out.smollm2_total_ms = r["smollm2_total_ms"];
-    if (typeof r["ode_ms"] === "number")
-        out.ode_ms = r["ode_ms"];
-    if (typeof r["total_ms"] === "number")
-        out.total_ms = r["total_ms"];
-    if (typeof r["backendDevice"] === "number")
-        out.backendDevice = r["backendDevice"];
+    if (typeof r['vision_ms'] === 'number')
+        out.vision_ms = r['vision_ms'];
+    if (typeof r['prefill_compute_ms'] === 'number')
+        out.prefill_compute_ms = r['prefill_compute_ms'];
+    if (typeof r['prefill_total_ms'] === 'number')
+        out.prefill_total_ms = r['prefill_total_ms'];
+    if (typeof r['smollm2_compute_ms'] === 'number')
+        out.smollm2_compute_ms = r['smollm2_compute_ms'];
+    if (typeof r['smollm2_total_ms'] === 'number')
+        out.smollm2_total_ms = r['smollm2_total_ms'];
+    if (typeof r['ode_ms'] === 'number')
+        out.ode_ms = r['ode_ms'];
+    if (typeof r['total_ms'] === 'number')
+        out.total_ms = r['total_ms'];
+    if (typeof r['backendDevice'] === 'number')
+        out.backendDevice = r['backendDevice'];
     return Object.keys(out).length > 0 ? out : undefined;
 }
 export async function vlaRun(request) {
@@ -63,17 +63,17 @@ export async function vlaRun(request) {
         state,
         tokens,
         mask,
-        ...(noise && { noise }),
+        ...(noise && { noise })
     });
     const result = await response.await();
     const hp = model.hparams;
     if (!hp) {
-        throw new Error("VLA model hparams unavailable after run");
+        throw new Error('VLA model hparams unavailable after run');
     }
     return {
         actions: f32ToBase64(result.actions),
         actionDim: hp.actionDim,
         chunkSize: hp.chunkSize,
-        ...(pickStats(result.stats) && { stats: pickStats(result.stats) }),
+        ...(pickStats(result.stats) && { stats: pickStats(result.stats) })
     };
 }

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

@@ -1,4 +1,4 @@
-import { type CreateModelParams, type PluginModelResult } from "../../../../schemas/index";
+import { type CreateModelParams, type PluginModelResult } from '../../../../schemas/index';
 export declare const vlaPlugin: {
     modelType: "ggml-vla";
     displayName: string;
@@ -53,6 +53,11 @@ export declare const vlaPlugin: {
                     discrete: "discrete";
                     continuous: "continuous";
                 }>>;
+                imageInputMode: import("zod").ZodOptional<import("zod").ZodEnum<{
+                    pixels: "pixels";
+                    patches: "patches";
+                }>>;
+                imagePatchElems: import("zod").ZodOptional<import("zod").ZodNumber>;
             }, import("zod/v4/core").$strip>;
             backendName: import("zod").ZodNullable<import("zod").ZodString>;
         }, import("zod/v4/core").$strip>>;

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

@@ -1,8 +1,8 @@
-import { VlaModel } from "@qvac/vla-ggml";
-import { definePlugin, defineHandler, vlaConfigSchema, vlaRunRequestSchema, vlaRunResponseSchema, vlaHparamsRequestSchema, vlaHparamsResponseSchema, 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 { VlaModel } from '@qvac/vla-ggml';
+import { definePlugin, defineHandler, vlaConfigSchema, vlaRunRequestSchema, vlaRunResponseSchema, vlaHparamsRequestSchema, vlaHparamsResponseSchema, 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';
 // 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.
@@ -16,7 +16,7 @@ function wrapVlaModel(inner, loadOpts) {
 }
 export const vlaPlugin = definePlugin({
     modelType: ModelType.ggmlVla,
-    displayName: "VLA (SmolVLA / π₀.₅ ggml)",
+    displayName: 'VLA (SmolVLA / π₀.₅ / GR00T ggml)',
     addonPackage: ADDON_VLA,
     loadConfigSchema: vlaConfigSchema,
     createModel(params) {
@@ -26,12 +26,12 @@ export const vlaPlugin = definePlugin({
         const inner = new VlaModel({
             files: { model: [params.modelPath] },
             ...(config.verbosity !== undefined && {
-                config: { verbosity: config.verbosity },
+                config: { verbosity: config.verbosity }
             }),
             logger,
-            opts: { stats: true },
+            opts: { stats: true }
         });
-        const backend = config.backend ?? "auto";
+        const backend = config.backend ?? 'auto';
         const model = wrapVlaModel(inner, { backend });
         return { model };
     },
@@ -43,15 +43,15 @@ export const vlaPlugin = definePlugin({
             // The vla-ggml addon exposes a model-wide cancel(): the running ODE /
             // SmolLM2 prefill is interrupted. Mirrors the diffusion plugin's
             // cancel surface.
-            cancel: { scope: "model", hard: true },
-            handler: vlaRun,
+            cancel: { scope: 'model', hard: true },
+            handler: vlaRun
         }),
         vlaHparams: defineHandler({
             requestSchema: vlaHparamsRequestSchema,
             responseSchema: vlaHparamsResponseSchema,
             streaming: false,
-            cancel: { scope: "none" },
-            handler: vlaGetHparams,
-        }),
-    },
+            cancel: { scope: 'none' },
+            handler: vlaGetHparams
+        })
+    }
 });

package/dist/server/bare/plugins/index.d.ts

@@ -1,12 +1,12 @@
-export { llmPlugin } from "./llamacpp-completion/plugin";
-export { embeddingsPlugin } from "./llamacpp-embedding/plugin";
-export { whisperPlugin } from "./whispercpp-transcription/plugin";
-export { bciPlugin } from "./bci-whispercpp-transcription/plugin";
-export { parakeetPlugin } from "./parakeet-transcription/plugin";
-export { nmtPlugin } from "./nmtcpp-translation/plugin";
-export { ttsPlugin } from "./tts-ggml/plugin";
-export { ocrPlugin } from "./ggml-ocr/plugin";
-export { diffusionPlugin } from "./sdcpp-generation/plugin";
-export { vlaPlugin } from "./ggml-vla/plugin";
-export { classificationPlugin } from "./ggml-classification/plugin";
+export { llmPlugin } from './llamacpp-completion/plugin';
+export { embeddingsPlugin } from './llamacpp-embedding/plugin';
+export { whisperPlugin } from './whispercpp-transcription/plugin';
+export { bciPlugin } from './bci-whispercpp-transcription/plugin';
+export { parakeetPlugin } from './parakeet-transcription/plugin';
+export { nmtPlugin } from './nmtcpp-translation/plugin';
+export { ttsPlugin } from './tts-ggml/plugin';
+export { ocrPlugin } from './ggml-ocr/plugin';
+export { diffusionPlugin } from './sdcpp-generation/plugin';
+export { vlaPlugin } from './ggml-vla/plugin';
+export { classificationPlugin } from './ggml-classification/plugin';
 //# sourceMappingURL=index.d.ts.map

package/dist/server/bare/plugins/index.js

@@ -1,11 +1,11 @@
-export { llmPlugin } from "./llamacpp-completion/plugin.js";
-export { embeddingsPlugin } from "./llamacpp-embedding/plugin.js";
-export { whisperPlugin } from "./whispercpp-transcription/plugin.js";
-export { bciPlugin } from "./bci-whispercpp-transcription/plugin.js";
-export { parakeetPlugin } from "./parakeet-transcription/plugin.js";
-export { nmtPlugin } from "./nmtcpp-translation/plugin.js";
-export { ttsPlugin } from "./tts-ggml/plugin.js";
-export { ocrPlugin } from "./ggml-ocr/plugin.js";
-export { diffusionPlugin } from "./sdcpp-generation/plugin.js";
-export { vlaPlugin } from "./ggml-vla/plugin.js";
-export { classificationPlugin } from "./ggml-classification/plugin.js";
+export { llmPlugin } from './llamacpp-completion/plugin.js';
+export { embeddingsPlugin } from './llamacpp-embedding/plugin.js';
+export { whisperPlugin } from './whispercpp-transcription/plugin.js';
+export { bciPlugin } from './bci-whispercpp-transcription/plugin.js';
+export { parakeetPlugin } from './parakeet-transcription/plugin.js';
+export { nmtPlugin } from './nmtcpp-translation/plugin.js';
+export { ttsPlugin } from './tts-ggml/plugin.js';
+export { ocrPlugin } from './ggml-ocr/plugin.js';
+export { diffusionPlugin } from './sdcpp-generation/plugin.js';
+export { vlaPlugin } from './ggml-vla/plugin.js';
+export { classificationPlugin } from './ggml-classification/plugin.js';

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

@@ -0,0 +1,23 @@
+/**
+ * Helper for detecting the llama.cpp addon's `Cancelled` status error
+ * (`LlmErrors.hpp::Cancelled = 27`) on the continuous-batching path.
+ *
+ * When a batch is cancelled while it still has prompts queued behind the
+ * `parallel` slot limit, `ContinuousBatchScheduler::cancelPendingLocked`
+ * fails the whole batch group with a `Cancelled` `StatusError`, which
+ * `processBatch` rethrows — so `model.run(prompts)` rejects rather than
+ * resolving with partial outputs (see
+ * `packages/llm-llamacpp/docs/continuous-batching.md` "Cancellation
+ * semantics"). In-flight slots are still cancelled gracefully, but the
+ * shared group carries the error.
+ *
+ * The addon's JS-facing throw goes through `js_throw_error(env, code,
+ * msg)` (see `JsUtils.hpp::JSCATCH`) where `code` comes from
+ * `qvac_errors::StatusError::codeString()` and formats as
+ * `"[ <addonId> :: Cancelled ]"`. This helper lets the batch handler
+ * recognise that rejection so it can complete the run with cancelled
+ * terminal events (matching the SDK's graceful cancel semantics) instead
+ * of surfacing a generic `CompletionFailedError`.
+ */
+export declare function isAddonCancelledError(err: unknown): boolean;
+//# sourceMappingURL=batch-cancelled.d.ts.map

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

@@ -0,0 +1,30 @@
+/**
+ * Helper for detecting the llama.cpp addon's `Cancelled` status error
+ * (`LlmErrors.hpp::Cancelled = 27`) on the continuous-batching path.
+ *
+ * When a batch is cancelled while it still has prompts queued behind the
+ * `parallel` slot limit, `ContinuousBatchScheduler::cancelPendingLocked`
+ * fails the whole batch group with a `Cancelled` `StatusError`, which
+ * `processBatch` rethrows — so `model.run(prompts)` rejects rather than
+ * resolving with partial outputs (see
+ * `packages/llm-llamacpp/docs/continuous-batching.md` "Cancellation
+ * semantics"). In-flight slots are still cancelled gracefully, but the
+ * shared group carries the error.
+ *
+ * The addon's JS-facing throw goes through `js_throw_error(env, code,
+ * msg)` (see `JsUtils.hpp::JSCATCH`) where `code` comes from
+ * `qvac_errors::StatusError::codeString()` and formats as
+ * `"[ <addonId> :: Cancelled ]"`. This helper lets the batch handler
+ * recognise that rejection so it can complete the run with cancelled
+ * terminal events (matching the SDK's graceful cancel semantics) instead
+ * of surfacing a generic `CompletionFailedError`.
+ */
+export function isAddonCancelledError(err) {
+    if (typeof err !== 'object' || err === null)
+        return false;
+    const code = err.code;
+    // Anchor to the codeString tail (`[ <addonId> :: Cancelled ]`) so a
+    // hypothetical sibling like `CancelledByPolicy` after an addon-side
+    // rename doesn't false-positive here.
+    return typeof code === 'string' && /::\s*Cancelled\s*\]/.test(code);
+}

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

@@ -0,0 +1,32 @@
+import type { AbortSignal } from 'bare-abort-controller';
+import type { BatchCompletionStreamPrompt, CompletionStats } from '../../../../../schemas/index';
+import type { DisposableScope } from '../../../runtime/disposable-scope';
+import type { Logger } from '../../../../../logging/types';
+type BatchModelEvent = {
+    type: 'ids';
+    ids: string[];
+} | {
+    type: 'token';
+    id: string;
+    token: string;
+};
+type BatchModelResult = {
+    id: string;
+    output: string;
+};
+type BatchModelStreamResult = {
+    ids: string[];
+    results: BatchModelResult[];
+    modelExecutionMs: number;
+    stats?: CompletionStats;
+};
+export declare function batchCompletion(params: {
+    modelId: string;
+    prompts: BatchCompletionStreamPrompt[];
+}, opts: {
+    signal: AbortSignal;
+    scope: DisposableScope;
+    logger?: Logger;
+}): AsyncGenerator<BatchModelEvent, BatchModelStreamResult, unknown>;
+export {};
+//# sourceMappingURL=batch-completion-stream.d.ts.map

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

@@ -0,0 +1,99 @@
+import { TOOLS_MODE } from '../../../../../schemas/tools.js';
+import { getModel, getModelConfig } from '../../../registry/model-registry.js';
+import { getServerLogger } from '../../../../../logging/index.js';
+import { nowMs } from '../../../../../profiling/index.js';
+import { buildStreamResult } from '../../../../../profiling/model-execution.js';
+import { getResponseFormatJsonSchema } from '../../../../utils/response-format.js';
+import { transformMessages } from './completion-stream.js';
+import { normalizeCompletionStats } from './completion-stats.js';
+import { appendToolsToHistory, prependToolsToHistory } from '../../../../utils/tool-integration.js';
+const logger = getServerLogger();
+function runBatchModel(model, prompts) {
+    const run = model.run.bind(model);
+    return run(prompts);
+}
+function mergeGenerationParams(generationParams, responseFormat) {
+    if (!responseFormat)
+        return generationParams;
+    const jsonSchema = getResponseFormatJsonSchema(responseFormat);
+    if (jsonSchema === undefined)
+        return generationParams;
+    return {
+        ...(generationParams ?? {}),
+        json_schema: jsonSchema
+    };
+}
+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);
+    }
+    // Uses the same attachment expansion as single completion: each SDK
+    // attachment becomes an addon `type: "media"` message before the text turn.
+    return transformMessages(historyWithTools);
+}
+function buildBatchPrompt(prompt, options) {
+    const mergedGenerationParams = mergeGenerationParams(prompt.generationParams, prompt.responseFormat);
+    return {
+        ...(prompt.id !== undefined && { id: prompt.id }),
+        prompt: renderPromptHistory(prompt, options),
+        ...(mergedGenerationParams && {
+            runOptions: { generationParams: mergedGenerationParams }
+        })
+    };
+}
+function isBatchOutputChunk(output) {
+    return (output !== null &&
+        typeof output === 'object' &&
+        'id' in output &&
+        'chunk' in output &&
+        typeof output.id === 'string' &&
+        typeof output.chunk === 'string');
+}
+export async function* batchCompletion(params, opts) {
+    const { modelId, prompts } = params;
+    const { signal, scope } = opts;
+    const requestLogger = opts.logger ?? logger;
+    const model = getModel(modelId);
+    const modelConfig = getModelConfig(modelId);
+    const renderOptions = {
+        toolsEnabled: modelConfig.tools === true,
+        toolsMode: modelConfig.toolsMode
+    };
+    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)}`);
+            });
+        }
+    };
+    signal.addEventListener('abort', onAbort, { once: true });
+    if (signal.aborted)
+        onAbort();
+    scope.defer(() => {
+        signal.removeEventListener('abort', onAbort);
+    });
+    const addonPrompts = prompts.map((prompt) => buildBatchPrompt(prompt, renderOptions));
+    const modelStart = nowMs();
+    const response = await runBatchModel(model, addonPrompts);
+    const ids = response.ids;
+    yield { type: 'ids', ids };
+    for await (const output of response.iterate()) {
+        if (!isBatchOutputChunk(output))
+            continue;
+        yield { type: 'token', id: output.id, token: output.chunk };
+    }
+    const results = await response.await();
+    const modelExecutionMs = nowMs() - modelStart;
+    const stats = normalizeCompletionStats(response.stats);
+    return {
+        ...buildStreamResult(modelExecutionMs, stats),
+        ids,
+        results
+    };
+}

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

@@ -1,6 +1,6 @@
 export declare function logCacheStatus(cacheKey: string, isReusing: boolean): void;
 export declare function logCacheInit(cacheKey: string, systemPrompt: string, toolCount: number): void;
-export declare function logMessagesToAddon(messages: unknown[], phase?: "CACHE_INIT" | "PROMPT_SEND" | "NO_CACHE"): 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;
 export declare function logCacheSaveError(sessionPath: string, err: unknown): void;

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

@@ -1,32 +1,32 @@
-import { getServerLogger } from "../../../../../logging/index.js";
+import { getServerLogger } from '../../../../../logging/index.js';
 const logger = getServerLogger();
 function formatMessages(messages) {
     return messages
         .map((m) => {
-        const role = m.role || m.type || "?";
+        const role = m.role || m.type || '?';
         const content = m.content
             ? m.content.length > 40
-                ? m.content.substring(0, 40) + "..."
+                ? m.content.substring(0, 40) + '...'
                 : m.content
-            : m.name || "(no content)";
+            : m.name || '(no content)';
         return `{${role}: "${content}"}`;
     })
-        .join(", ");
+        .join(', ');
 }
 export function logCacheStatus(cacheKey, isReusing) {
-    const status = isReusing ? "REUSING" : "CREATING";
+    const status = isReusing ? 'REUSING' : 'CREATING';
     logger.debug(`[kv-cache] [${cacheKey}] ${status} cache`);
 }
 export function logCacheInit(cacheKey, systemPrompt, toolCount) {
     const promptLen = systemPrompt.length;
     logger.debug(`[kv-cache] [${cacheKey}] Initializing cache (prompt: ${promptLen} chars, tools: ${toolCount})`);
 }
-export function logMessagesToAddon(messages, phase = "PROMPT_SEND") {
+export function logMessagesToAddon(messages, phase = 'PROMPT_SEND') {
     const typedMessages = messages;
     logger.debug(`[kv-cache] [${phase}] Sending ${typedMessages.length} msg(s): [${formatMessages(typedMessages)}]`);
 }
 export function logCacheDisabled() {
-    logger.debug("[kv-cache] Cache disabled");
+    logger.debug('[kv-cache] Cache disabled');
 }
 export function logCacheSave(sessionPath) {
     logger.debug(`[kv-cache] Saving session: ...${sessionPath.slice(-20)}`);

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

@@ -1,10 +1,11 @@
-import type { LlmStats } from "../../../types/addon-responses";
+import type { LlmStats } from '../../../types/addon-responses';
 export declare function normalizeCompletionStats(stats: LlmStats | undefined): {
     timeToFirstToken?: number | undefined;
     tokensPerSecond?: number | undefined;
     cacheTokens?: number | undefined;
     promptTokens?: number | undefined;
     generatedTokens?: number | undefined;
-    backendDevice?: "cpu" | "gpu" | undefined;
+    avgConcurrentSeq?: number | undefined;
+    backendDevice?: "gpu" | "cpu" | undefined;
 } | undefined;
 //# sourceMappingURL=completion-stats.d.ts.map

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

@@ -9,19 +9,22 @@ export function normalizeCompletionStats(stats) {
     const cacheTokens = finiteNumber(stats.CacheTokens);
     const promptTokens = finiteNumber(stats.promptTokens);
     const generatedTokens = finiteNumber(stats.generatedTokens);
+    const avgConcurrentSeq = finiteNumber(stats.avgConcurrentSeq);
     const normalized = {
         ...(timeToFirstToken !== undefined && { timeToFirstToken }),
         ...(tokensPerSecond !== undefined && { tokensPerSecond }),
         ...(cacheTokens !== undefined && { cacheTokens }),
         ...(promptTokens !== undefined && { promptTokens }),
         ...(generatedTokens !== undefined && { generatedTokens }),
-        ...(stats.backendDevice !== undefined && { backendDevice: stats.backendDevice }),
+        ...(avgConcurrentSeq !== undefined && { avgConcurrentSeq }),
+        ...(stats.backendDevice !== undefined && { backendDevice: stats.backendDevice })
     };
     if (timeToFirstToken === undefined &&
         tokensPerSecond === undefined &&
         cacheTokens === undefined &&
         promptTokens === undefined &&
         generatedTokens === undefined &&
+        avgConcurrentSeq === undefined &&
         stats.backendDevice === undefined) {
         return undefined;
     }

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

@@ -1,12 +1,30 @@
-import type { AbortSignal } from "bare-abort-controller";
-import type { CompletionParams, CompletionStats, GenerationParams, ResponseFormat, Tool, ToolCall, ToolDialect } from "../../../../../schemas/index";
-import type { DisposableScope } from "../../../runtime/disposable-scope";
-import type { Logger } from "../../../../../logging/types";
+import type { AbortSignal } from 'bare-abort-controller';
+import type { CompletionParams, CompletionStats, GenerationParams, ResponseFormat, Tool, ToolCall, ToolDialect } from '../../../../../schemas/index';
+import type { DisposableScope } from '../../../runtime/disposable-scope';
+import type { Logger } from '../../../../../logging/types';
 interface CompletionResult {
     modelExecutionMs: number;
     stats?: CompletionStats;
     toolCalls: ToolCall[];
 }
+interface ChatHistory {
+    role?: string;
+    content?: string;
+    type?: string;
+    name?: string;
+    description?: string;
+    parameters?: unknown;
+}
+export type CompletionGenerationParams = GenerationParams & {
+    json_schema?: string;
+};
+export declare function transformMessages(messages: Array<{
+    role: string;
+    content: string;
+    attachments?: {
+        path: string;
+    }[] | undefined;
+} | Tool>): ChatHistory[];
 export declare function completion(params: CompletionParams & {
     tools?: Tool[];
     generationParams?: GenerationParams;