@qvac/sdk 0.10.2 → 0.12.0

package/dist/models/update-models/naming.js

@@ -317,21 +317,35 @@ function generateDiffusionName({ filename, modelName, quantization, params, tags
 }
 function generateParakeetName({ filename, lowerPath, quantization, }) {
     const lower = filename.toLowerCase();
-    // Detect model variant from registry path
     let variant = "";
-    if (lowerPath.includes("parakeet-tdt") || lowerPath.includes("parakeet/")) {
-        variant = "TDT";
+    if (lower.includes("sortformer") || lower.includes("diar_streaming")) {
+        variant = "SORTFORMER";
     }
-    else if (lowerPath.includes("parakeet-ctc")) {
+    else if (lower.includes("ctc") || lowerPath.includes("parakeet-ctc")) {
         variant = "CTC";
     }
-    else if (lowerPath.includes("eou") || lowerPath.includes("parakeet-rs")) {
+    else if (lower.includes("eou") || lowerPath.includes("parakeet-rs")) {
         variant = "EOU";
     }
-    else if (lowerPath.includes("sortformer")) {
-        variant = "SORTFORMER";
+    else if (lower.includes("tdt") || lowerPath.includes("parakeet-tdt")) {
+        variant = "TDT";
+    }
+    if (lower.endsWith(".gguf")) {
+        const paramsMatch = filename.match(/(?:^|[-_])(\d+(?:\.\d+)?[mb])(?=[-_.])/i);
+        const versionMatch = filename.match(/[-_]v(\d+(?:\.\d+)?)/i);
+        const speakerMatch = filename.match(/(\d+spk)/i);
+        const paramsHint = paramsMatch ? paramsMatch[1] : "";
+        const versionHint = versionMatch ? `V${versionMatch[1]}` : "";
+        const speakerHint = speakerMatch ? speakerMatch[1] : "";
+        const nameParts = [
+            variant,
+            paramsHint,
+            speakerHint,
+            versionHint,
+            quantization,
+        ].filter((p) => p && p !== "");
+        return `PARAKEET_${nameParts.map(cleanPart).join("_")}`;
     }
-    // Detect file role from filename
     let fileRole = "";
     if (lower.includes("encoder") && (lower.endsWith(".data") || lower.endsWith(".onnx.data"))) {
         fileRole = "ENCODER_DATA";

package/dist/pear/pre.d.ts

@@ -5,6 +5,9 @@
  * 1. Generate `qvac/worker.pear.entry.mjs` with selected plugins
  * 2. Persist `pear.stage.entrypoints` to package.json for routing
  *
+ * Note: `qvac verify bundle` is not wired here yet — run it manually
+ * (locally and/or in CI) before `pear stage` / `pear run`.
+ *
  * @example package.json configuration
  * ```json
  * {

package/dist/pear/pre.js

@@ -5,6 +5,9 @@
  * 1. Generate `qvac/worker.pear.entry.mjs` with selected plugins
  * 2. Persist `pear.stage.entrypoints` to package.json for routing
  *
+ * Note: `qvac verify bundle` is not wired here yet — run it manually
+ * (locally and/or in CI) before `pear stage` / `pear run`.
+ *
  * @example package.json configuration
  * ```json
  * {
@@ -29,18 +32,22 @@ const BUILTIN_PLUGINS = [
     "@qvac/sdk/llamacpp-embedding/plugin",
     "@qvac/sdk/whispercpp-transcription/plugin",
     "@qvac/sdk/nmtcpp-translation/plugin",
-    "@qvac/sdk/onnx-tts/plugin",
+    "@qvac/sdk/tts-ggml/plugin",
     "@qvac/sdk/onnx-ocr/plugin",
     "@qvac/sdk/sdcpp-generation/plugin",
+    "@qvac/sdk/ggml-vla/plugin",
+    "@qvac/sdk/ggml-classification/plugin",
 ];
 const BUILTIN_PLUGIN_EXPORTS = {
     "llamacpp-completion": "llmPlugin",
     "llamacpp-embedding": "embeddingsPlugin",
     "whispercpp-transcription": "whisperPlugin",
     "nmtcpp-translation": "nmtPlugin",
-    "onnx-tts": "ttsPlugin",
+    "tts-ggml": "ttsPlugin",
     "onnx-ocr": "ocrPlugin",
     "sdcpp-generation": "diffusionPlugin",
+    "ggml-vla": "vlaPlugin",
+    "ggml-classification": "classificationPlugin",
 };
 const SDK_NAME = "@qvac/sdk";
 const DEFAULT_PEAR_WORKER = "worker.js";

package/dist/schemas/cancel.d.ts

@@ -1,55 +1,199 @@
 import { z } from "zod";
+/**
+ * Public-API base for the broad-cancel escape hatch. Kept exported so
+ * the bare-side `cancel({ modelId, kind? })` helper can parse the
+ * `modelId` field consistently with the wire envelope.
+ */
 export declare const cancelInferenceBaseSchema: z.ZodObject<{
     modelId: z.ZodString;
 }, z.core.$strip>;
-declare const cancelParamsSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+/**
+ * Coarse kind narrowing for the broad-cancel escape hatch. Matches the
+ * server-side `RequestKind` union in `server/bare/runtime/request-context.ts`
+ * — keep the two lists in sync. The kind is optional; omitting it
+ * cancels every in-flight request on the model regardless of kind
+ * (the "cancel everything on this model" sweep used by model-unload
+ * and app-shutdown paths).
+ */
+declare const cancelKindSchema: z.ZodEnum<{
+    completion: "completion";
+    embeddings: "embeddings";
+    transcribe: "transcribe";
+    translate: "translate";
+    diffusion: "diffusion";
+    tts: "tts";
+    ocr: "ocr";
+    vla: "vla";
+    finetune: "finetune";
+    loadModel: "loadModel";
+    downloadAsset: "downloadAsset";
+    rag: "rag";
+}>;
+/**
+ * Targeted cancel by `requestId` — the primary cancel path in
+ * SDK 0.11.0. Pair with the `requestId` field exposed on
+ * `CompletionRun` (and the decorated promises returned by
+ * `loadModel(...)`, `downloadAsset(...)`, `embed(...)`,
+ * `transcribe(...)`, `rag*(...)` etc.) to cancel a specific in-flight
+ * request rather than every request running on a given model.
+ *
+ * `clearCache` is honoured only when the targeted request is a
+ * `downloadAsset` — it propagates onto the underlying download
+ * transfer so the partial file is deleted when the last subscriber
+ * leaves. Ignored for other kinds.
+ */
+declare const cancelByRequestIdParamsSchema: z.ZodObject<{
+    operation: z.ZodLiteral<"request">;
+    requestId: z.ZodString;
+    clearCache: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+/**
+ * Broad cancel escape hatch — abort every in-flight request running on
+ * a model (optionally narrowed by `kind`). Kept indefinitely as the
+ * non-`requestId` cancel surface for model-unload, app-shutdown, and
+ * admin sweeps where the caller doesn't have a `requestId` to hand.
+ *
+ * Replaces the legacy per-kind discriminator arms (`"inference"`,
+ * `"embeddings"`, `"downloadAsset"`, `"rag"`) with a single `"broad"`
+ * arm plus an optional `kind` field. The old arms went away as part
+ * of the 0.11.0 cleanup once every handler was on the registry; the
+ * wire shape collapse is a `[bc]` for any external caller hand-rolling
+ * the old RPC envelope. The public-API `cancel(...)` function in
+ * `client/api/cancel.ts` keeps the old `{ operation: "inference", modelId }`
+ * / `{ operation: "embeddings", modelId }` forms callable and translates
+ * them into this new shape at the client boundary, so consumers using
+ * the official SDK client see no change.
+ */
+declare const cancelBroadParamsSchema: z.ZodObject<{
+    operation: z.ZodLiteral<"broad">;
     modelId: z.ZodString;
-    operation: z.ZodLiteral<"inference">;
-}, z.core.$strip>, z.ZodObject<{
-    operation: z.ZodLiteral<"downloadAsset">;
-    downloadKey: z.ZodString;
+    kind: z.ZodOptional<z.ZodEnum<{
+        completion: "completion";
+        embeddings: "embeddings";
+        transcribe: "transcribe";
+        translate: "translate";
+        diffusion: "diffusion";
+        tts: "tts";
+        ocr: "ocr";
+        vla: "vla";
+        finetune: "finetune";
+        loadModel: "loadModel";
+        downloadAsset: "downloadAsset";
+        rag: "rag";
+    }>>;
+}, z.core.$strip>;
+declare const cancelParamsSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    operation: z.ZodLiteral<"request">;
+    requestId: z.ZodString;
     clearCache: z.ZodOptional<z.ZodBoolean>;
-    delegate: z.ZodOptional<z.ZodObject<{
-        providerPublicKey: z.ZodString;
-        timeout: z.ZodOptional<z.ZodNumber>;
-        healthCheckTimeout: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>>;
-}, z.core.$strip>, z.ZodObject<{
-    operation: z.ZodLiteral<"rag">;
-    workspace: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>, z.ZodObject<{
+    operation: z.ZodLiteral<"broad">;
     modelId: z.ZodString;
-    operation: z.ZodLiteral<"embeddings">;
+    kind: z.ZodOptional<z.ZodEnum<{
+        completion: "completion";
+        embeddings: "embeddings";
+        transcribe: "transcribe";
+        translate: "translate";
+        diffusion: "diffusion";
+        tts: "tts";
+        ocr: "ocr";
+        vla: "vla";
+        finetune: "finetune";
+        loadModel: "loadModel";
+        downloadAsset: "downloadAsset";
+        rag: "rag";
+    }>>;
 }, z.core.$strip>], "operation">;
 export declare const cancelRequestSchema: z.ZodIntersection<z.ZodObject<{
     type: z.ZodLiteral<"cancel">;
 }, z.core.$strip>, z.ZodDiscriminatedUnion<[z.ZodObject<{
-    modelId: z.ZodString;
-    operation: z.ZodLiteral<"inference">;
-}, z.core.$strip>, z.ZodObject<{
-    operation: z.ZodLiteral<"downloadAsset">;
-    downloadKey: z.ZodString;
+    operation: z.ZodLiteral<"request">;
+    requestId: z.ZodString;
     clearCache: z.ZodOptional<z.ZodBoolean>;
-    delegate: z.ZodOptional<z.ZodObject<{
-        providerPublicKey: z.ZodString;
-        timeout: z.ZodOptional<z.ZodNumber>;
-        healthCheckTimeout: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>>;
-}, z.core.$strip>, z.ZodObject<{
-    operation: z.ZodLiteral<"rag">;
-    workspace: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>, z.ZodObject<{
+    operation: z.ZodLiteral<"broad">;
     modelId: z.ZodString;
-    operation: z.ZodLiteral<"embeddings">;
+    kind: z.ZodOptional<z.ZodEnum<{
+        completion: "completion";
+        embeddings: "embeddings";
+        transcribe: "transcribe";
+        translate: "translate";
+        diffusion: "diffusion";
+        tts: "tts";
+        ocr: "ocr";
+        vla: "vla";
+        finetune: "finetune";
+        loadModel: "loadModel";
+        downloadAsset: "downloadAsset";
+        rag: "rag";
+    }>>;
 }, z.core.$strip>], "operation">>;
 export declare const cancelResponseSchema: z.ZodObject<{
     type: z.ZodLiteral<"cancel">;
     success: z.ZodBoolean;
+    cancelled: z.ZodOptional<z.ZodNumber>;
     error: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
+/**
+ * Sugar for the most common new path — `cancel({ requestId })`. The
+ * client accepts either this shape (no `operation`) or the explicit
+ * `{ operation: "request", requestId }` and normalises before sending.
+ */
+export declare const cancelByRequestIdSugarSchema: z.ZodObject<{
+    requestId: z.ZodString;
+    clearCache: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+/**
+ * Sugar for the broad-cancel escape hatch — `cancel({ modelId, kind? })`.
+ * Translates to `{ operation: "broad", modelId, kind? }` at the client
+ * boundary.
+ */
+export declare const cancelBroadSugarSchema: z.ZodObject<{
+    modelId: z.ZodString;
+    kind: z.ZodOptional<z.ZodEnum<{
+        completion: "completion";
+        embeddings: "embeddings";
+        transcribe: "transcribe";
+        translate: "translate";
+        diffusion: "diffusion";
+        tts: "tts";
+        ocr: "ocr";
+        vla: "vla";
+        finetune: "finetune";
+        loadModel: "loadModel";
+        downloadAsset: "downloadAsset";
+        rag: "rag";
+    }>>;
+}, z.core.$strict>;
+/**
+ * Legacy per-kind broad-cancel sugars retained at the public-API
+ * boundary so existing callers of `cancel({ operation: "inference",
+ * modelId })` / `cancel({ operation: "embeddings", modelId })` keep
+ * working without code changes. The client wrapper translates these
+ * into the new `{ operation: "broad", modelId, kind: ... }` wire
+ * shape. New callers should prefer `cancel({ requestId })` or
+ * `cancel({ modelId, kind? })`.
+ */
+export declare const cancelLegacyInferenceSugarSchema: z.ZodObject<{
+    operation: z.ZodLiteral<"inference">;
+    modelId: z.ZodString;
+}, z.core.$strip>;
+export declare const cancelLegacyEmbeddingsSugarSchema: z.ZodObject<{
+    operation: z.ZodLiteral<"embeddings">;
+    modelId: z.ZodString;
+}, z.core.$strip>;
 export type CancelParams = z.infer<typeof cancelParamsSchema>;
 export type CancelInferenceBaseParams = z.infer<typeof cancelInferenceBaseSchema>;
+export type CancelByRequestIdParams = z.infer<typeof cancelByRequestIdParamsSchema>;
+export type CancelBroadParams = z.infer<typeof cancelBroadParamsSchema>;
+export type CancelByRequestIdSugar = z.infer<typeof cancelByRequestIdSugarSchema>;
+export type CancelBroadSugar = z.infer<typeof cancelBroadSugarSchema>;
+export type CancelLegacyInferenceSugar = z.infer<typeof cancelLegacyInferenceSugarSchema>;
+export type CancelLegacyEmbeddingsSugar = z.infer<typeof cancelLegacyEmbeddingsSugarSchema>;
+export type CancelKind = z.infer<typeof cancelKindSchema>;
 export type CancelRequest = z.infer<typeof cancelRequestSchema>;
 export type CancelResponse = z.infer<typeof cancelResponseSchema>;
+/** Public client-API input — accepts the wire union *or* the requestId/broad sugars and the legacy per-kind sugars. */
+export type CancelClientInput = CancelParams | CancelByRequestIdSugar | CancelBroadSugar | CancelLegacyInferenceSugar | CancelLegacyEmbeddingsSugar;
 export {};
 //# sourceMappingURL=cancel.d.ts.map

package/dist/schemas/cancel.js

@@ -1,39 +1,140 @@
 import { z } from "zod";
-import { delegateBaseSchema } from "./delegate.js";
 const cancelBaseSchema = z.object({
     type: z.literal("cancel"),
 });
+/**
+ * Public-API base for the broad-cancel escape hatch. Kept exported so
+ * the bare-side `cancel({ modelId, kind? })` helper can parse the
+ * `modelId` field consistently with the wire envelope.
+ */
 export const cancelInferenceBaseSchema = z.object({
     modelId: z.string().describe("The model ID to cancel inference for"),
 });
-const cancelInferenceParamsSchema = cancelInferenceBaseSchema.extend({
-    operation: z.literal("inference").describe("Operation type"),
-});
-const cancelDownloadParamsSchema = z.object({
-    operation: z.literal("downloadAsset").describe("Operation type"),
-    downloadKey: z.string().describe("The download key to cancel"),
+/**
+ * Coarse kind narrowing for the broad-cancel escape hatch. Matches the
+ * server-side `RequestKind` union in `server/bare/runtime/request-context.ts`
+ * — keep the two lists in sync. The kind is optional; omitting it
+ * cancels every in-flight request on the model regardless of kind
+ * (the "cancel everything on this model" sweep used by model-unload
+ * and app-shutdown paths).
+ */
+const cancelKindSchema = z
+    .enum([
+    "completion",
+    "embeddings",
+    "transcribe",
+    "translate",
+    "diffusion",
+    "tts",
+    "ocr",
+    "vla",
+    "finetune",
+    "loadModel",
+    "downloadAsset",
+    "rag",
+])
+    .describe("Optional kind narrowing for the broad cancel. Omitting it cancels every in-flight request on the model.");
+/**
+ * Targeted cancel by `requestId` — the primary cancel path in
+ * SDK 0.11.0. Pair with the `requestId` field exposed on
+ * `CompletionRun` (and the decorated promises returned by
+ * `loadModel(...)`, `downloadAsset(...)`, `embed(...)`,
+ * `transcribe(...)`, `rag*(...)` etc.) to cancel a specific in-flight
+ * request rather than every request running on a given model.
+ *
+ * `clearCache` is honoured only when the targeted request is a
+ * `downloadAsset` — it propagates onto the underlying download
+ * transfer so the partial file is deleted when the last subscriber
+ * leaves. Ignored for other kinds.
+ */
+const cancelByRequestIdParamsSchema = z.object({
+    operation: z.literal("request").describe("Operation type"),
+    requestId: z
+        .string()
+        .min(1)
+        .describe("Identifier of the specific in-flight request to cancel — the value exposed on the result object returned by long-running calls (e.g. `completion(...)`, `loadModel(...)`, `downloadAsset(...)`)."),
     clearCache: z
         .boolean()
         .optional()
-        .describe("If true, deletes the partial download file"),
-    delegate: delegateBaseSchema.optional(),
-});
-const cancelRagParamsSchema = z.object({
-    operation: z.literal("rag").describe("Operation type"),
-    workspace: z.string().optional().describe("The RAG workspace to cancel"),
+        .describe("Download-only: if true, deletes the partial download file when the subscriber leaves. Ignored for non-download kinds."),
 });
-const cancelEmbeddingsParamsSchema = cancelInferenceBaseSchema.extend({
-    operation: z.literal("embeddings").describe("Operation type"),
+/**
+ * Broad cancel escape hatch — abort every in-flight request running on
+ * a model (optionally narrowed by `kind`). Kept indefinitely as the
+ * non-`requestId` cancel surface for model-unload, app-shutdown, and
+ * admin sweeps where the caller doesn't have a `requestId` to hand.
+ *
+ * Replaces the legacy per-kind discriminator arms (`"inference"`,
+ * `"embeddings"`, `"downloadAsset"`, `"rag"`) with a single `"broad"`
+ * arm plus an optional `kind` field. The old arms went away as part
+ * of the 0.11.0 cleanup once every handler was on the registry; the
+ * wire shape collapse is a `[bc]` for any external caller hand-rolling
+ * the old RPC envelope. The public-API `cancel(...)` function in
+ * `client/api/cancel.ts` keeps the old `{ operation: "inference", modelId }`
+ * / `{ operation: "embeddings", modelId }` forms callable and translates
+ * them into this new shape at the client boundary, so consumers using
+ * the official SDK client see no change.
+ */
+const cancelBroadParamsSchema = z.object({
+    operation: z.literal("broad").describe("Operation type"),
+    modelId: z
+        .string()
+        .describe("Cancel every in-flight request on this model"),
+    kind: cancelKindSchema.optional(),
 });
 const cancelParamsSchema = z.discriminatedUnion("operation", [
-    cancelInferenceParamsSchema,
-    cancelDownloadParamsSchema,
-    cancelRagParamsSchema,
-    cancelEmbeddingsParamsSchema,
+    cancelByRequestIdParamsSchema,
+    cancelBroadParamsSchema,
 ]);
 export const cancelRequestSchema = z.intersection(cancelBaseSchema, cancelParamsSchema);
 export const cancelResponseSchema = z.object({
     type: z.literal("cancel"),
     success: z.boolean(),
+    /**
+     * Number of in-flight contexts that this call flipped to
+     * `cancelling` (already-cancelled contexts are not counted, so
+     * callers can rely on the value to log "n requests cancelled" once
+     * without double-counting). Always present on `success: true`.
+     */
+    cancelled: z.number().int().nonnegative().optional(),
     error: z.string().optional(),
 });
+/**
+ * Sugar for the most common new path — `cancel({ requestId })`. The
+ * client accepts either this shape (no `operation`) or the explicit
+ * `{ operation: "request", requestId }` and normalises before sending.
+ */
+export const cancelByRequestIdSugarSchema = z
+    .object({
+    requestId: z.string().min(1),
+    clearCache: z.boolean().optional(),
+})
+    .strict();
+/**
+ * Sugar for the broad-cancel escape hatch — `cancel({ modelId, kind? })`.
+ * Translates to `{ operation: "broad", modelId, kind? }` at the client
+ * boundary.
+ */
+export const cancelBroadSugarSchema = z
+    .object({
+    modelId: z.string().min(1),
+    kind: cancelKindSchema.optional(),
+})
+    .strict();
+/**
+ * Legacy per-kind broad-cancel sugars retained at the public-API
+ * boundary so existing callers of `cancel({ operation: "inference",
+ * modelId })` / `cancel({ operation: "embeddings", modelId })` keep
+ * working without code changes. The client wrapper translates these
+ * into the new `{ operation: "broad", modelId, kind: ... }` wire
+ * shape. New callers should prefer `cancel({ requestId })` or
+ * `cancel({ modelId, kind? })`.
+ */
+export const cancelLegacyInferenceSugarSchema = z.object({
+    operation: z.literal("inference"),
+    modelId: z.string().min(1),
+});
+export const cancelLegacyEmbeddingsSugarSchema = z.object({
+    operation: z.literal("embeddings"),
+    modelId: z.string().min(1),
+});

package/dist/schemas/classification.d.ts

@@ -0,0 +1,53 @@
+import { z } from "zod";
+export declare const classificationConfigSchema: z.ZodObject<{
+    modelPath: z.ZodOptional<z.ZodString>;
+    topK: z.ZodOptional<z.ZodNumber>;
+    nativeLogger: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const classifyParamsSchema: z.ZodObject<{
+    modelId: z.ZodString;
+    image: z.ZodString;
+    topK: z.ZodOptional<z.ZodNumber>;
+    width: z.ZodOptional<z.ZodNumber>;
+    height: z.ZodOptional<z.ZodNumber>;
+    channels: z.ZodOptional<z.ZodLiteral<3>>;
+}, z.core.$strip>;
+export declare const classifyRequestSchema: z.ZodObject<{
+    modelId: z.ZodString;
+    image: z.ZodString;
+    topK: z.ZodOptional<z.ZodNumber>;
+    width: z.ZodOptional<z.ZodNumber>;
+    height: z.ZodOptional<z.ZodNumber>;
+    channels: z.ZodOptional<z.ZodLiteral<3>>;
+    type: z.ZodLiteral<"classify">;
+}, z.core.$strip>;
+export declare const classificationResultSchema: z.ZodObject<{
+    label: z.ZodString;
+    confidence: z.ZodNumber;
+}, z.core.$strip>;
+export declare const classifyResponseSchema: z.ZodObject<{
+    type: z.ZodLiteral<"classify">;
+    results: z.ZodArray<z.ZodObject<{
+        label: z.ZodString;
+        confidence: z.ZodNumber;
+    }, z.core.$strip>>;
+    done: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type ClassificationConfig = z.infer<typeof classificationConfigSchema>;
+export type ClassifyParams = z.infer<typeof classifyParamsSchema>;
+export type ClassifyRequest = z.infer<typeof classifyRequestSchema>;
+export type ClassificationResult = z.infer<typeof classificationResultSchema>;
+export type ClassifyResponse = z.infer<typeof classifyResponseSchema>;
+export interface ClassifyClientParams {
+    modelId: string;
+    /** JPEG or PNG buffer. */
+    image: Uint8Array;
+    topK?: number;
+    /** Raw RGB image width (required for raw bytes). */
+    width?: number;
+    /** Raw RGB image height (required for raw bytes). */
+    height?: number;
+    /** Channel count — must be 3 for raw RGB. */
+    channels?: 3;
+}
+//# sourceMappingURL=classification.d.ts.map

package/dist/schemas/classification.js

@@ -0,0 +1,33 @@
+import { z } from "zod";
+export const classificationConfigSchema = z.object({
+    /** Absolute path to the GGUF weights file. Defaults to the bundled model inside @qvac/classification-ggml. */
+    modelPath: z.string().optional(),
+    /** Limit returned results to the top-K classes. Default: all classes. */
+    topK: z.number().int().optional(),
+    /** Forward native C++ log lines through the SDK logger. Off by default. */
+    nativeLogger: z.boolean().optional(),
+});
+export const classifyParamsSchema = z.object({
+    modelId: z.string(),
+    /** JPEG or PNG buffer encoded as base64, or raw RGB bytes. */
+    image: z.string(),
+    topK: z.number().int().optional(),
+    /** Raw RGB image width (required for raw bytes). */
+    width: z.number().int().optional(),
+    /** Raw RGB image height (required for raw bytes). */
+    height: z.number().int().optional(),
+    /** Channel count — must be 3 for raw RGB. */
+    channels: z.literal(3).optional(),
+});
+export const classifyRequestSchema = classifyParamsSchema.extend({
+    type: z.literal("classify"),
+});
+export const classificationResultSchema = z.object({
+    label: z.string(),
+    confidence: z.number(),
+});
+export const classifyResponseSchema = z.object({
+    type: z.literal("classify"),
+    results: z.array(classificationResultSchema),
+    done: z.boolean().optional(),
+});