@qvac/sdk 0.15.0 → 0.16.0

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

@@ -84,7 +84,7 @@ export declare const completionClientParamsSchema: z.ZodObject<{
                     integer: "integer";
                 }>;
                 description: z.ZodOptional<z.ZodString>;
-                enum: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                enum: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>>;
             }, z.core.$strip>>;
             required: z.ZodOptional<z.ZodArray<z.ZodString>>;
         }, z.core.$strip>;
@@ -153,7 +153,7 @@ export declare const completionStreamRequestSchema: z.ZodObject<{
                     integer: "integer";
                 }>;
                 description: z.ZodOptional<z.ZodString>;
-                enum: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                enum: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>>;
             }, z.core.$strip>>;
             required: z.ZodOptional<z.ZodArray<z.ZodString>>;
         }, z.core.$strip>;
@@ -273,6 +273,187 @@ export declare const completionStreamResponseSchema: z.ZodObject<{
         }, z.core.$strip>>;
     }, z.core.$strict>]>>;
 }, z.core.$strict>;
+export declare const completionOrchestrateRequestSchema: z.ZodObject<{
+    history: z.ZodArray<z.ZodObject<{
+        role: z.ZodString;
+        content: z.ZodString;
+        attachments: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    modelId: z.ZodString;
+    tools: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        type: z.ZodLiteral<"function">;
+        name: z.ZodString;
+        description: z.ZodString;
+        parameters: z.ZodObject<{
+            type: z.ZodLiteral<"object">;
+            properties: z.ZodRecord<z.ZodString, z.ZodObject<{
+                type: z.ZodEnum<{
+                    string: "string";
+                    number: "number";
+                    boolean: "boolean";
+                    object: "object";
+                    array: "array";
+                    integer: "integer";
+                }>;
+                description: z.ZodOptional<z.ZodString>;
+                enum: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>>;
+            }, z.core.$strip>>;
+            required: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>;
+    }, z.core.$strip>>>;
+    stream: z.ZodBoolean;
+    kvCache: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>>;
+    generationParams: z.ZodOptional<z.ZodObject<{
+        temp: z.ZodOptional<z.ZodNumber>;
+        top_p: z.ZodOptional<z.ZodNumber>;
+        top_k: z.ZodOptional<z.ZodNumber>;
+        predict: z.ZodOptional<z.ZodNumber>;
+        seed: z.ZodOptional<z.ZodNumber>;
+        frequency_penalty: z.ZodOptional<z.ZodNumber>;
+        presence_penalty: z.ZodOptional<z.ZodNumber>;
+        repeat_penalty: z.ZodOptional<z.ZodNumber>;
+        reasoning_budget: z.ZodOptional<z.ZodNumber>;
+        remove_thinking_from_context: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>>;
+    captureThinking: z.ZodOptional<z.ZodBoolean>;
+    emitRawDeltas: z.ZodOptional<z.ZodBoolean>;
+    toolDialect: z.ZodOptional<z.ZodEnum<{
+        hermes: "hermes";
+        pythonic: "pythonic";
+        json: "json";
+        harmony: "harmony";
+        qwen35: "qwen35";
+        gemma4: "gemma4";
+    }>>;
+    responseFormat: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"text">;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"json_object">;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"json_schema">;
+        json_schema: z.ZodObject<{
+            name: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            schema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            strict: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>;
+    }, z.core.$strict>], "type">>;
+    requestId: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"completionOrchestrate">;
+    maxToolTurns: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+/**
+ * Downstream frame of the orchestrated completion duplex stream. Exactly one
+ * payload field is set per frame:
+ *
+ * - `events` — pass-through of the inner completion turn's events (with
+ *   `turn` identifying which generation pass they belong to).
+ * - `toolCallback` — the worker is asking the CLIENT to run a tool. The
+ *   client executes its registered handler and writes a JSON line
+ *   (`toolCallbackResultSchema`) up the request stream. The worker blocks
+ *   this run (not the socket) until the matching `callId` arrives.
+ * - `done` — terminal frame; the loop ended (final answer produced, error,
+ *   cancellation, or the `maxToolTurns` cap).
+ *
+ * Only a LOCAL worker may emit `toolCallback`: tool handlers execute code on
+ * the client machine, so a remote delegate streaming through this shape must
+ * never trigger them.
+ */
+export declare const completionOrchestrateResponseSchema: z.ZodObject<{
+    type: z.ZodLiteral<"completionOrchestrate">;
+    turn: z.ZodOptional<z.ZodNumber>;
+    events: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        type: z.ZodLiteral<"contentDelta">;
+        seq: z.ZodNumber;
+        text: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"rawDelta">;
+        seq: z.ZodNumber;
+        text: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"thinkingDelta">;
+        seq: z.ZodNumber;
+        text: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"toolCall">;
+        seq: z.ZodNumber;
+        call: z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            arguments: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            raw: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"toolError">;
+        seq: z.ZodNumber;
+        error: z.ZodObject<{
+            code: z.ZodEnum<{
+                PARSE_ERROR: "PARSE_ERROR";
+                VALIDATION_ERROR: "VALIDATION_ERROR";
+                UNKNOWN_TOOL: "UNKNOWN_TOOL";
+            }>;
+            message: z.ZodString;
+            raw: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"completionStats">;
+        seq: z.ZodNumber;
+        stats: z.ZodObject<{
+            timeToFirstToken: z.ZodOptional<z.ZodNumber>;
+            tokensPerSecond: z.ZodOptional<z.ZodNumber>;
+            cacheTokens: z.ZodOptional<z.ZodNumber>;
+            promptTokens: z.ZodOptional<z.ZodNumber>;
+            generatedTokens: z.ZodOptional<z.ZodNumber>;
+            avgConcurrentSeq: z.ZodOptional<z.ZodNumber>;
+            backendDevice: z.ZodOptional<z.ZodEnum<{
+                gpu: "gpu";
+                cpu: "cpu";
+            }>>;
+        }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"completionDone">;
+        seq: z.ZodNumber;
+        stopReason: z.ZodLiteral<"error">;
+        error: z.ZodObject<{
+            message: z.ZodString;
+        }, z.core.$strip>;
+        raw: z.ZodOptional<z.ZodObject<{
+            fullText: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"completionDone">;
+        seq: z.ZodNumber;
+        stopReason: z.ZodOptional<z.ZodEnum<{
+            cancelled: "cancelled";
+            eos: "eos";
+            length: "length";
+            stopSequence: "stopSequence";
+        }>>;
+        raw: z.ZodOptional<z.ZodObject<{
+            fullText: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strict>]>>>;
+    toolCallback: z.ZodOptional<z.ZodObject<{
+        callId: z.ZodString;
+        name: z.ZodString;
+        arguments: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.core.$strip>>;
+    done: z.ZodOptional<z.ZodBoolean>;
+    stopReason: z.ZodOptional<z.ZodLiteral<"maxToolTurns">>;
+}, z.core.$strict>;
+/**
+ * Upstream JSON line the client writes after running a tool callback.
+ * Newline-delimited on the duplex request stream, after the initial request
+ * payload. `error` reports a handler failure; the worker forwards it to the
+ * model as the tool result so the loop can recover or finish.
+ */
+export declare const toolCallbackResultSchema: z.ZodObject<{
+    callId: z.ZodString;
+    result: z.ZodOptional<z.ZodUnknown>;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
 export type GenerationParams = z.infer<typeof generationParamsSchema>;
 export type CompletionParams = z.infer<typeof completionParamsSchema>;
 export type ToolDialect = z.infer<typeof toolDialectSchema>;
@@ -280,5 +461,8 @@ export type ResponseFormat = z.infer<typeof responseFormatSchema>;
 export type CompletionClientParams = z.input<typeof completionClientParamsSchema>;
 export type CompletionStreamRequest = z.infer<typeof completionStreamRequestSchema>;
 export type CompletionStreamResponse = z.infer<typeof completionStreamResponseSchema>;
+export type CompletionOrchestrateRequest = z.infer<typeof completionOrchestrateRequestSchema>;
+export type CompletionOrchestrateResponse = z.infer<typeof completionOrchestrateResponseSchema>;
+export type ToolCallbackResult = z.infer<typeof toolCallbackResultSchema>;
 export type Attachment = z.infer<typeof attachmentSchema>;
 //# sourceMappingURL=completion-stream.d.ts.map

package/dist/schemas/completion-stream.js

@@ -164,3 +164,70 @@ export const completionStreamResponseSchema = z
     events: z.array(completionEventSchema)
 })
     .strict();
+// ============================================
+// Worker-orchestrated completion (duplex)
+// ============================================
+export const completionOrchestrateRequestSchema = completionClientParamsBaseSchema
+    .extend({
+    type: z.literal('completionOrchestrate'),
+    maxToolTurns: z
+        .number()
+        .int()
+        .min(1)
+        .max(32)
+        .optional()
+        .describe('Upper bound on generation turns the worker will run before ending the ' +
+        'loop with `stopReason: "maxToolTurns"`. Each turn is one completion ' +
+        'pass; a turn that requests tool calls consumes callbacks and starts ' +
+        'the next turn. Defaults to 8.')
+})
+    .superRefine(refineNoToolsWithStructuredOutput);
+/**
+ * Downstream frame of the orchestrated completion duplex stream. Exactly one
+ * payload field is set per frame:
+ *
+ * - `events` — pass-through of the inner completion turn's events (with
+ *   `turn` identifying which generation pass they belong to).
+ * - `toolCallback` — the worker is asking the CLIENT to run a tool. The
+ *   client executes its registered handler and writes a JSON line
+ *   (`toolCallbackResultSchema`) up the request stream. The worker blocks
+ *   this run (not the socket) until the matching `callId` arrives.
+ * - `done` — terminal frame; the loop ended (final answer produced, error,
+ *   cancellation, or the `maxToolTurns` cap).
+ *
+ * Only a LOCAL worker may emit `toolCallback`: tool handlers execute code on
+ * the client machine, so a remote delegate streaming through this shape must
+ * never trigger them.
+ */
+export const completionOrchestrateResponseSchema = z
+    .object({
+    type: z.literal('completionOrchestrate'),
+    turn: z.number().int().nonnegative().optional(),
+    events: z.array(completionEventSchema).optional(),
+    toolCallback: z
+        .object({
+        callId: z.string().describe('Correlates the upstream result line to this request.'),
+        name: z.string(),
+        arguments: z.record(z.string(), z.unknown())
+    })
+        .optional(),
+    done: z.boolean().optional(),
+    stopReason: z
+        .literal('maxToolTurns')
+        .optional()
+        .describe('Set on the terminal `done` frame only when the loop stopped because it ' +
+        'hit `maxToolTurns` (the model still wanted a tool). Absent on a natural ' +
+        'finish, so the caller can tell a truncated run from a completed one.')
+})
+    .strict();
+/**
+ * Upstream JSON line the client writes after running a tool callback.
+ * Newline-delimited on the duplex request stream, after the initial request
+ * payload. `error` reports a handler failure; the worker forwards it to the
+ * model as the tool result so the loop can recover or finish.
+ */
+export const toolCallbackResultSchema = z.object({
+    callId: z.string(),
+    result: z.unknown().optional(),
+    error: z.string().optional()
+});

package/dist/schemas/constants-registry.d.ts

@@ -0,0 +1,67 @@
+import { z } from 'zod';
+/**
+ * Every public constant `enum` from index.ts that downstream (non-JS)
+ * client generators should get as a real, named type instead of a
+ * hardcoded string/number. `build-contract.ts` merges each of these
+ * directly into `schema.json`'s `$defs` (same `z.toJSONSchema` call, same
+ * generator run as every request/response type), tagged with an
+ * `x-enum-varnames` hint so datamodel-code-generator preserves the
+ * original key names instead of slugging them from the bare value — plain
+ * JSON Schema `enum:` only carries values, not names, so without that hint
+ * `PluginId`/`Verbosity` (whose keys aren't derivable from their values)
+ * would lose their names entirely.
+ *
+ * A constant only reaches other languages if it's registered here. See
+ * `.cursor/rules/sdk/public-constants-contract.mdc`: any new public
+ * constant meant for downstream SDKs must be a `z.enum(...)` added here,
+ * not just a bare `export const` in its own schema file — otherwise it
+ * silently never leaves JS.
+ *
+ * Scoped to name→value maps (`z.enum`) only. A standalone scalar constant
+ * (e.g. `VLA_DEFAULT_IMAGE_SIZE`) has no natural JSON Schema representation
+ * as a plain value — a `const`-only schema generates an awkward
+ * `RootModel[Literal[...]]` wrapper class in Python, not a usable
+ * constant — so scalars aren't covered by this registry.
+ */
+export declare const constantsRegistry: {
+    readonly ModelType: z.ZodEnum<{
+        readonly llamacppCompletion: "llamacpp-completion";
+        readonly whispercppTranscription: "whispercpp-transcription";
+        readonly bciWhispercppTranscription: "bci-whispercpp-transcription";
+        readonly llamacppEmbedding: "llamacpp-embedding";
+        readonly nmtcppTranslation: "nmtcpp-translation";
+        readonly onnxTts: "onnx-tts";
+        readonly ttsGgml: "tts-ggml";
+        readonly parakeetTranscription: "parakeet-transcription";
+        readonly ggmlOcr: "ggml-ocr";
+        readonly sdcppGeneration: "sdcpp-generation";
+        readonly ggmlVla: "ggml-vla";
+        readonly ggmlClassification: "ggml-classification";
+    }>;
+    readonly ToolsMode: z.ZodEnum<{
+        readonly static: "static";
+        readonly dynamic: "dynamic";
+    }>;
+    readonly Verbosity: z.ZodEnum<{
+        readonly ERROR: 0;
+        readonly WARN: 1;
+        readonly INFO: 2;
+        readonly DEBUG: 3;
+    }>;
+    readonly PluginId: z.ZodEnum<{
+        readonly LLM: "@qvac/sdk/llamacpp-completion/plugin";
+        readonly EMBEDDING: "@qvac/sdk/llamacpp-embedding/plugin";
+        readonly WHISPER: "@qvac/sdk/whispercpp-transcription/plugin";
+        readonly BCI: "@qvac/sdk/bci-whispercpp-transcription/plugin";
+        readonly NMT: "@qvac/sdk/nmtcpp-translation/plugin";
+        readonly TTS: "@qvac/sdk/tts-ggml/plugin";
+        readonly OCR: "@qvac/sdk/ggml-ocr/plugin";
+        readonly DIFFUSION: "@qvac/sdk/sdcpp-generation/plugin";
+        readonly VLA: "@qvac/sdk/ggml-vla/plugin";
+        readonly CLASSIFICATION: "@qvac/sdk/ggml-classification/plugin";
+    }>;
+    readonly SupportedAudioFormat: z.ZodEnum<{
+        [k: string]: string;
+    }>;
+};
+//# sourceMappingURL=constants-registry.d.ts.map

package/dist/schemas/constants-registry.js

@@ -0,0 +1,51 @@
+import { z } from 'zod';
+import { ModelType } from './model-types.js';
+import { TOOLS_MODE } from './tools.js';
+import { VERBOSITY } from './llamacpp-config.js';
+import { PLUGIN_LLM, PLUGIN_EMBEDDING, PLUGIN_WHISPER, PLUGIN_BCI, PLUGIN_NMT, PLUGIN_TTS, PLUGIN_OCR, PLUGIN_DIFFUSION, PLUGIN_VLA, PLUGIN_CLASSIFICATION } from './plugin.js';
+import { SUPPORTED_AUDIO_FORMATS } from '../constants/audio.js';
+/**
+ * Every public constant `enum` from index.ts that downstream (non-JS)
+ * client generators should get as a real, named type instead of a
+ * hardcoded string/number. `build-contract.ts` merges each of these
+ * directly into `schema.json`'s `$defs` (same `z.toJSONSchema` call, same
+ * generator run as every request/response type), tagged with an
+ * `x-enum-varnames` hint so datamodel-code-generator preserves the
+ * original key names instead of slugging them from the bare value — plain
+ * JSON Schema `enum:` only carries values, not names, so without that hint
+ * `PluginId`/`Verbosity` (whose keys aren't derivable from their values)
+ * would lose their names entirely.
+ *
+ * A constant only reaches other languages if it's registered here. See
+ * `.cursor/rules/sdk/public-constants-contract.mdc`: any new public
+ * constant meant for downstream SDKs must be a `z.enum(...)` added here,
+ * not just a bare `export const` in its own schema file — otherwise it
+ * silently never leaves JS.
+ *
+ * Scoped to name→value maps (`z.enum`) only. A standalone scalar constant
+ * (e.g. `VLA_DEFAULT_IMAGE_SIZE`) has no natural JSON Schema representation
+ * as a plain value — a `const`-only schema generates an awkward
+ * `RootModel[Literal[...]]` wrapper class in Python, not a usable
+ * constant — so scalars aren't covered by this registry.
+ */
+export const constantsRegistry = {
+    ModelType: z.enum(ModelType),
+    ToolsMode: z.enum(TOOLS_MODE),
+    Verbosity: z.enum(VERBOSITY),
+    PluginId: z.enum({
+        LLM: PLUGIN_LLM,
+        EMBEDDING: PLUGIN_EMBEDDING,
+        WHISPER: PLUGIN_WHISPER,
+        BCI: PLUGIN_BCI,
+        NMT: PLUGIN_NMT,
+        TTS: PLUGIN_TTS,
+        OCR: PLUGIN_OCR,
+        DIFFUSION: PLUGIN_DIFFUSION,
+        VLA: PLUGIN_VLA,
+        CLASSIFICATION: PLUGIN_CLASSIFICATION
+    }),
+    // Derived from SUPPORTED_AUDIO_FORMATS itself (e.g. '.mp3' -> 'MP3') rather
+    // than a hand-written record, so the varnames can't drift from the one
+    // source of truth every other consumer of SUPPORTED_AUDIO_FORMATS shares.
+    SupportedAudioFormat: z.enum(Object.fromEntries(SUPPORTED_AUDIO_FORMATS.map((ext) => [ext.slice(1).toUpperCase(), ext])))
+};

package/dist/schemas/delete-cache.js

@@ -1,14 +1,18 @@
 import { z } from 'zod';
 export const deleteCacheRequestSchema = z.union([
-    z.object({
+    z
+        .object({
         type: z.literal('deleteCache'),
         all: z.literal(true)
-    }),
-    z.object({
+    })
+        .meta({ title: 'DeleteCacheAllRequest' }),
+    z
+        .object({
         type: z.literal('deleteCache'),
         kvCacheKey: z.string(),
         modelId: z.string().optional()
     })
+        .meta({ title: 'DeleteCacheKvEntryRequest' })
 ]);
 export const deleteCacheResponseSchema = z.object({
     type: z.literal('deleteCache'),

package/dist/schemas/engine-addon-map.d.ts

@@ -14,6 +14,7 @@ export declare const ENGINE_TO_ADDON: {
     readonly "ggml-classification": "classification";
     readonly 'onnx-vad': "vad";
 };
+export declare const LEGACY_ENGINE_TO_CANONICAL: Record<string, ModelRegistryEngine>;
 export declare function resolveCanonicalEngine(engine: string): ModelRegistryEngine | null;
 export declare function getAddonFromEngine(engine: ModelRegistryEngine): ModelRegistryEntryAddon;
 //# sourceMappingURL=engine-addon-map.d.ts.map

package/dist/schemas/engine-addon-map.js

@@ -20,7 +20,7 @@ export const ENGINE_TO_ADDON = {
 };
 // Legacy engine names → canonical engine.
 // Used for backward compatibility with old registry data that uses @qvac/* package names.
-const LEGACY_ENGINE_TO_CANONICAL = {
+export const LEGACY_ENGINE_TO_CANONICAL = {
     [ADDON_LLM]: ModelType.llamacppCompletion,
     [ADDON_WHISPER]: ModelType.whispercppTranscription,
     [ADDON_BCI]: ModelType.bciWhispercppTranscription,

package/dist/schemas/finetune.js

@@ -96,19 +96,22 @@ export const finetuneRunRequestSchema = finetuneRunParamsSchemaBase
         .optional()
         .describe('Stable identifier for this in-flight finetune, generated by the client at call time. Surfaces on the registry so callers can target it with `cancel({ requestId })`. Optional on the wire — the server falls back to a server-generated id when the field is missing.')
 })
-    .strict();
+    .strict()
+    .meta({ title: 'FinetuneRunRequest' });
 export const finetuneGetStateRequestSchema = finetuneRunParamsSchemaBase
     .extend({
     type: z.literal('finetune'),
     operation: z.literal('getState')
 })
-    .strict();
+    .strict()
+    .meta({ title: 'FinetuneGetStateRequest' });
 export const finetuneStopRequestSchema = finetuneModelParamsSchema
     .extend({
     type: z.literal('finetune'),
     operation: z.enum(['pause', 'cancel'])
 })
-    .strict();
+    .strict()
+    .meta({ title: 'FinetuneStopRequest' });
 export const finetuneRequestSchema = z.union([
     finetuneRunRequestSchema,
     finetuneGetStateRequestSchema,

package/dist/schemas/get-loaded-model-info.d.ts

@@ -16,6 +16,14 @@ export declare const loadedModelInfoSchema: z.ZodDiscriminatedUnion<[z.ZodObject
     loadedAt: z.ZodCoercedDate<unknown>;
     name: z.ZodOptional<z.ZodString>;
     path: z.ZodOptional<z.ZodString>;
+    toolDialect: z.ZodOptional<z.ZodEnum<{
+        hermes: "hermes";
+        pythonic: "pythonic";
+        json: "json";
+        harmony: "harmony";
+        qwen35: "qwen35";
+        gemma4: "gemma4";
+    }>>;
 }, z.core.$strip>, z.ZodObject<{
     modelId: z.ZodString;
     isDelegated: z.ZodLiteral<true>;
@@ -36,6 +44,14 @@ export declare const getLoadedModelInfoResponseSchema: z.ZodObject<{
         loadedAt: z.ZodCoercedDate<unknown>;
         name: z.ZodOptional<z.ZodString>;
         path: z.ZodOptional<z.ZodString>;
+        toolDialect: z.ZodOptional<z.ZodEnum<{
+            hermes: "hermes";
+            pythonic: "pythonic";
+            json: "json";
+            harmony: "harmony";
+            qwen35: "qwen35";
+            gemma4: "gemma4";
+        }>>;
     }, z.core.$strip>, z.ZodObject<{
         modelId: z.ZodString;
         isDelegated: z.ZodLiteral<true>;

package/dist/schemas/get-loaded-model-info.js

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+import { toolDialectSchema } from './completion-stream.js';
 export const getLoadedModelInfoParamsSchema = z.object({
     modelId: z.string()
 });
@@ -10,9 +11,12 @@ const delegatedProviderInfoSchema = z.object({
 });
 /**
  * Loaded local model: routing plugin known on this node, so modelType +
- * handler vocabulary are authoritative.
+ * handler vocabulary are authoritative. `toolDialect` is the tool-call dialect
+ * the completion normalizer parses for this model (completion-capable models
+ * only), letting a consumer replay a prior tool call in the model's own dialect.
  */
-const localLoadedModelInfoSchema = z.object({
+const localLoadedModelInfoSchema = z
+    .object({
     modelId: z.string(),
     isDelegated: z.literal(false),
     modelType: z.string(),
@@ -21,19 +25,23 @@ const localLoadedModelInfoSchema = z.object({
     addonPackage: z.string().optional(),
     loadedAt: z.coerce.date(),
     name: z.string().optional(),
-    path: z.string().optional()
-});
+    path: z.string().optional(),
+    toolDialect: toolDialectSchema.optional()
+})
+    .meta({ title: 'LocalLoadedModelInfo' });
 /**
  * Loaded delegated model: this node only stores routing info, so `modelType`,
  * `displayName`, `addonPackage`, `loadedAt`, `name`, and `path` are absent,
  * and `handlers` is always empty.
  */
-const delegatedLoadedModelInfoSchema = z.object({
+const delegatedLoadedModelInfoSchema = z
+    .object({
     modelId: z.string(),
     isDelegated: z.literal(true),
     handlers: z.array(z.string()),
     providerInfo: delegatedProviderInfoSchema
-});
+})
+    .meta({ title: 'DelegatedLoadedModelInfo' });
 export const loadedModelInfoSchema = z.discriminatedUnion('isDelegated', [
     localLoadedModelInfoSchema,
     delegatedLoadedModelInfoSchema

package/dist/schemas/llamacpp-config.d.ts

@@ -23,7 +23,12 @@ export declare const llmConfigBaseSchema: z.ZodObject<{
     predict: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<-1>, z.ZodLiteral<-2>, z.ZodNumber]>>;
     system_prompt: z.ZodOptional<z.ZodString>;
     no_mmap: z.ZodOptional<z.ZodBoolean>;
-    verbosity: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>]>>;
+    verbosity: z.ZodOptional<z.ZodEnum<{
+        readonly ERROR: 0;
+        readonly WARN: 1;
+        readonly INFO: 2;
+        readonly DEBUG: 3;
+    }>>;
     presence_penalty: z.ZodOptional<z.ZodNumber>;
     frequency_penalty: z.ZodOptional<z.ZodNumber>;
     repeat_penalty: z.ZodOptional<z.ZodNumber>;
@@ -113,7 +118,12 @@ export declare const llmConfigSchema: z.ZodPipe<z.ZodObject<{
     predict: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<-1>, z.ZodLiteral<-2>, z.ZodNumber]>>;
     system_prompt: z.ZodOptional<z.ZodString>;
     no_mmap: z.ZodOptional<z.ZodBoolean>;
-    verbosity: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>]>>;
+    verbosity: z.ZodOptional<z.ZodEnum<{
+        readonly ERROR: 0;
+        readonly WARN: 1;
+        readonly INFO: 2;
+        readonly DEBUG: 3;
+    }>>;
     presence_penalty: z.ZodOptional<z.ZodNumber>;
     frequency_penalty: z.ZodOptional<z.ZodNumber>;
     repeat_penalty: z.ZodOptional<z.ZodNumber>;
@@ -304,7 +314,12 @@ export declare const embedConfigBaseSchema: z.ZodObject<{
         row: "row";
     }>>;
     tensorSplit: z.ZodOptional<z.ZodString>;
-    verbosity: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>]>>;
+    verbosity: z.ZodOptional<z.ZodEnum<{
+        readonly ERROR: 0;
+        readonly WARN: 1;
+        readonly INFO: 2;
+        readonly DEBUG: 3;
+    }>>;
     openclCacheDir: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export type EmbedConfigInput = z.infer<typeof embedConfigBaseSchema>;
@@ -347,7 +362,12 @@ export declare const embedConfigSchema: z.ZodPipe<z.ZodObject<{
         row: "row";
     }>>;
     tensorSplit: z.ZodOptional<z.ZodString>;
-    verbosity: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>]>>;
+    verbosity: z.ZodOptional<z.ZodEnum<{
+        readonly ERROR: 0;
+        readonly WARN: 1;
+        readonly INFO: 2;
+        readonly DEBUG: 3;
+    }>>;
     openclCacheDir: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>, z.ZodTransform<{
     gpuLayers: number | undefined;

package/dist/schemas/llamacpp-config.js

@@ -13,12 +13,7 @@ export const VERBOSITY = {
     INFO: 2,
     DEBUG: 3
 };
-const verbositySchema = z.union([
-    z.literal(VERBOSITY.ERROR),
-    z.literal(VERBOSITY.WARN),
-    z.literal(VERBOSITY.INFO),
-    z.literal(VERBOSITY.DEBUG)
-]);
+const verbositySchema = z.enum(VERBOSITY);
 // Base schema - validates types, all fields optional (for client-side validation)
 export const llmConfigBaseSchema = z.object({
     ctx_size: z.number().optional(),