@qvac/sdk 0.10.1 → 0.11.0

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
  * {

package/dist/schemas/cancel.d.ts

@@ -1,55 +1,194 @@
 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";
+    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";
+        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";
+        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";
+        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";
+        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,139 @@
 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",
+    "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),
+});