@qvac/sdk 0.15.0 → 0.17.0

package/dist/schemas/common.js

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 import { perCallProfilingSchema } from './profiling.js';
 import { heartbeatRequestSchema, heartbeatResponseSchema } from './heartbeat.js';
-import { completionStreamRequestSchema, completionStreamResponseSchema } from './completion-stream.js';
+import { completionOrchestrateRequestSchema, completionOrchestrateResponseSchema, completionStreamRequestSchema, completionStreamResponseSchema } from './completion-stream.js';
 import { batchCompletionStreamRequestSchema, batchCompletionStreamResponseSchema } from './batch-completion-stream.js';
 import { loadModelRequestSchema, loadModelResponseSchema, modelProgressUpdateSchema } from './load-model.js';
 import { downloadAssetRequestSchema, downloadAssetResponseSchema } from './download-asset.js';
@@ -28,12 +28,16 @@ import { modelRegistryListRequestSchema, modelRegistryListResponseSchema, modelR
 import { suspendRequestSchema, suspendResponseSchema } from './suspend.js';
 import { resumeRequestSchema, resumeResponseSchema } from './resume.js';
 import { stateRequestSchema, stateResponseSchema } from './state.js';
+import { getSystemResourcesRequestSchema, getSystemResourcesResponseSchema } from './system-resources.js';
 import { classifyRequestSchema, classifyResponseSchema } from './classification.js';
+import { audioGenStreamRequestSchema, audioGenStreamResponseSchema } from '../schemas/audio-gen.js';
 export const requestSchema = z.union([
+    audioGenStreamRequestSchema,
     heartbeatRequestSchema,
     loadModelRequestSchema,
     downloadAssetRequestSchema,
     completionStreamRequestSchema,
+    completionOrchestrateRequestSchema,
     batchCompletionStreamRequestSchema,
     unloadModelRequestSchema,
     transcribeRequestSchema,
@@ -65,13 +69,16 @@ export const requestSchema = z.union([
     suspendRequestSchema,
     resumeRequestSchema,
     stateRequestSchema,
+    getSystemResourcesRequestSchema,
     classifyRequestSchema
 ]);
 export const responseSchema = z.discriminatedUnion('type', [
+    audioGenStreamResponseSchema,
     heartbeatResponseSchema,
     loadModelResponseSchema,
     downloadAssetResponseSchema,
     completionStreamResponseSchema,
+    completionOrchestrateResponseSchema,
     batchCompletionStreamResponseSchema,
     unloadModelResponseSchema,
     modelProgressUpdateSchema,
@@ -107,6 +114,7 @@ export const responseSchema = z.discriminatedUnion('type', [
     suspendResponseSchema,
     resumeResponseSchema,
     stateResponseSchema,
+    getSystemResourcesResponseSchema,
     classifyResponseSchema
 ]);
 export const rpcOptionsSchema = z.object({

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

@@ -1,12 +1,13 @@
 import { z } from 'zod';
-import { type Tool, type ToolCallWithCall } from './tools';
-import type { ToolDialect } from './completion-stream';
+import { type Tool, type ToolCallWithCall } from './tools.js';
+import type { ToolDialect } from './completion-stream.js';
 export declare const completionStatsSchema: 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>;
+    emittedTokens: z.ZodOptional<z.ZodNumber>;
     avgConcurrentSeq: z.ZodOptional<z.ZodNumber>;
     backendDevice: z.ZodOptional<z.ZodEnum<{
         gpu: "gpu";
@@ -62,6 +63,7 @@ export declare const statsEventSchema: z.ZodObject<{
         cacheTokens: z.ZodOptional<z.ZodNumber>;
         promptTokens: z.ZodOptional<z.ZodNumber>;
         generatedTokens: z.ZodOptional<z.ZodNumber>;
+        emittedTokens: z.ZodOptional<z.ZodNumber>;
         avgConcurrentSeq: z.ZodOptional<z.ZodNumber>;
         backendDevice: z.ZodOptional<z.ZodEnum<{
             gpu: "gpu";
@@ -143,6 +145,7 @@ export declare const completionEventSchema: z.ZodUnion<readonly [z.ZodObject<{
         cacheTokens: z.ZodOptional<z.ZodNumber>;
         promptTokens: z.ZodOptional<z.ZodNumber>;
         generatedTokens: z.ZodOptional<z.ZodNumber>;
+        emittedTokens: z.ZodOptional<z.ZodNumber>;
         avgConcurrentSeq: z.ZodOptional<z.ZodNumber>;
         backendDevice: z.ZodOptional<z.ZodEnum<{
             gpu: "gpu";

package/dist/schemas/completion-event.js

@@ -5,7 +5,10 @@ export const completionStatsSchema = z.object({
     tokensPerSecond: z.number().optional(),
     cacheTokens: z.number().optional(),
     promptTokens: z.number().optional(),
+    // Decode count (`llama_perf` `n_eval`) — length / KV-cache budget decisions.
     generatedTokens: z.number().optional(),
+    // Non-empty addon stream pieces — prefer for OpenAI usage when present.
+    emittedTokens: z.number().optional(),
     avgConcurrentSeq: z.number().optional(),
     backendDevice: z.enum(['cpu', 'gpu']).optional()
 });

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

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-export { completionStatsSchema, type CompletionStats } from './completion-event';
+export { completionStatsSchema, type CompletionStats } from './completion-event.js';
 /**
  * Tool-call output dialect. Auto-detected from the model name; pass via
  * `completion({ toolDialect })` to override.
@@ -11,6 +11,8 @@ export { completionStatsSchema, type CompletionStats } from './completion-event'
  * - `"harmony"`:  `<|channel|>commentary to=functions.get_weather <|constrain|>json<|message|>{"city":"Tokyo"}<|call|>`
  * - `"qwen35"`:   `<tool_call><function=NAME><parameter=KEY>VALUE</parameter></function></tool_call>`
  * - `"gemma4"`:   `<|tool_call>call:NAME{key:<|"|>val<|"|>,...}<tool_call|>`
+ * - `"dsml"`:     `<｜DSML｜tool_calls><｜DSML｜invoke name="NAME"><｜DSML｜parameter name="KEY" string="true">VALUE</｜DSML｜parameter></｜DSML｜invoke></｜DSML｜tool_calls>`
+ *                 (DeepSeek Markup Language, emitted by DeepSeek V3.2 / V4)
  */
 export declare const toolDialectSchema: z.ZodEnum<{
     hermes: "hermes";
@@ -19,6 +21,7 @@ export declare const toolDialectSchema: z.ZodEnum<{
     harmony: "harmony";
     qwen35: "qwen35";
     gemma4: "gemma4";
+    dsml: "dsml";
 }>;
 export declare const attachmentSchema: z.ZodObject<{
     path: z.ZodString;
@@ -84,7 +87,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>;
@@ -112,6 +115,7 @@ export declare const completionClientParamsSchema: z.ZodObject<{
         harmony: "harmony";
         qwen35: "qwen35";
         gemma4: "gemma4";
+        dsml: "dsml";
     }>>;
     responseFormat: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
         type: z.ZodLiteral<"text">;
@@ -153,7 +157,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>;
@@ -181,6 +185,7 @@ export declare const completionStreamRequestSchema: z.ZodObject<{
         harmony: "harmony";
         qwen35: "qwen35";
         gemma4: "gemma4";
+        dsml: "dsml";
     }>>;
     responseFormat: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
         type: z.ZodLiteral<"text">;
@@ -243,6 +248,7 @@ export declare const completionStreamResponseSchema: z.ZodObject<{
             cacheTokens: z.ZodOptional<z.ZodNumber>;
             promptTokens: z.ZodOptional<z.ZodNumber>;
             generatedTokens: z.ZodOptional<z.ZodNumber>;
+            emittedTokens: z.ZodOptional<z.ZodNumber>;
             avgConcurrentSeq: z.ZodOptional<z.ZodNumber>;
             backendDevice: z.ZodOptional<z.ZodEnum<{
                 gpu: "gpu";
@@ -273,6 +279,189 @@ 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";
+        dsml: "dsml";
+    }>>;
+    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>;
+            emittedTokens: 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 +469,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

@@ -14,6 +14,8 @@ export { completionStatsSchema } from './completion-event.js';
  * - `"harmony"`:  `<|channel|>commentary to=functions.get_weather <|constrain|>json<|message|>{"city":"Tokyo"}<|call|>`
  * - `"qwen35"`:   `<tool_call><function=NAME><parameter=KEY>VALUE</parameter></function></tool_call>`
  * - `"gemma4"`:   `<|tool_call>call:NAME{key:<|"|>val<|"|>,...}<tool_call|>`
+ * - `"dsml"`:     `<｜DSML｜tool_calls><｜DSML｜invoke name="NAME"><｜DSML｜parameter name="KEY" string="true">VALUE</｜DSML｜parameter></｜DSML｜invoke></｜DSML｜tool_calls>`
+ *                 (DeepSeek Markup Language, emitted by DeepSeek V3.2 / V4)
  */
 export const toolDialectSchema = z.enum([
     'hermes',
@@ -21,7 +23,8 @@ export const toolDialectSchema = z.enum([
     'json',
     'harmony',
     'qwen35',
-    'gemma4'
+    'gemma4',
+    'dsml'
 ]);
 export const attachmentSchema = z.object({
     path: z
@@ -61,7 +64,7 @@ export const generationParamsSchema = z
     remove_thinking_from_context: z
         .boolean()
         .optional()
-        .describe('When the model emits a reasoning block during generation (e.g. `<think>...</think>` for the Qwen3 family, `<|channel>thought ... <channel|>` for Gemma 4), drop those tokens from the KV cache at end-of-generation so subsequent turns do not accumulate reasoning history. Defaults to `false`. No-op for models without a recognised reasoning channel. Throws on models with recurrent memory (SSM / hybrid SSM such as Qwen3.5), where the cache edit is unsupported.')
+        .describe('When the model emits a reasoning block during generation (e.g. `<think>...</think>` for the Qwen3 family, `<|channel>thought ... <channel|>` for Gemma 4), drop those tokens from the KV cache at end-of-generation so subsequent turns do not accumulate reasoning history. Defaults to `false`, except the Qwen3 reasoning family (Qwen3, Qwen3.5, Qwen3.6, including MoE variants), which defaults to `true`. No-op for models without a recognised reasoning channel. Supported on recurrent / hybrid-SSM models (e.g. Qwen3.5) via a state snapshot and replay when the reasoning close marker is a single token; on such a model with a multi-token close marker, enabling this fails with an error.')
 })
     .strict();
 const jsonSchemaObjectSchema = z.record(z.string(), z.unknown());
@@ -164,3 +167,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,69 @@
+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 audiogenGgml: "audiogen-ggml";
+        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 AUDIOGEN: "@qvac/sdk/audiogen-ggml/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,52 @@
+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_AUDIOGEN, 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,
+        AUDIOGEN: PLUGIN_AUDIOGEN,
+        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'),