@qvac/sdk 0.14.0 → 0.15.0

package/dist/schemas/completion-event.js

@@ -1,49 +1,50 @@
-import { z } from "zod";
-import { toolCallSchema, toolCallErrorSchema, } from "./tools.js";
+import { z } from 'zod';
+import { toolCallSchema, toolCallErrorSchema } from './tools.js';
 export const completionStatsSchema = z.object({
     timeToFirstToken: z.number().optional(),
     tokensPerSecond: z.number().optional(),
     cacheTokens: z.number().optional(),
     promptTokens: z.number().optional(),
     generatedTokens: z.number().optional(),
-    backendDevice: z.enum(["cpu", "gpu"]).optional(),
+    avgConcurrentSeq: z.number().optional(),
+    backendDevice: z.enum(['cpu', 'gpu']).optional()
 });
 export const seqSchema = z.number().int().nonnegative();
 export const contentDeltaEventSchema = z.object({
-    type: z.literal("contentDelta"),
+    type: z.literal('contentDelta'),
     seq: seqSchema,
-    text: z.string(),
+    text: z.string()
 });
 export const rawDeltaEventSchema = z.object({
-    type: z.literal("rawDelta"),
+    type: z.literal('rawDelta'),
     seq: seqSchema,
-    text: z.string(),
+    text: z.string()
 });
 export const thinkingDeltaEventSchema = z.object({
-    type: z.literal("thinkingDelta"),
+    type: z.literal('thinkingDelta'),
     seq: seqSchema,
-    text: z.string(),
+    text: z.string()
 });
 export const toolCallEventSchema = z.object({
-    type: z.literal("toolCall"),
+    type: z.literal('toolCall'),
     seq: seqSchema,
-    call: toolCallSchema,
+    call: toolCallSchema
 });
 export const toolErrorEventSchema = z.object({
-    type: z.literal("toolError"),
+    type: z.literal('toolError'),
     seq: seqSchema,
-    error: toolCallErrorSchema,
+    error: toolCallErrorSchema
 });
 export const statsEventSchema = z.object({
-    type: z.literal("completionStats"),
+    type: z.literal('completionStats'),
     seq: seqSchema,
-    stats: completionStatsSchema,
+    stats: completionStatsSchema
 });
 export const completionErrorSchema = z.object({
-    message: z.string(),
+    message: z.string()
 });
 const rawOutputSchema = z.object({
-    fullText: z.string(),
+    fullText: z.string()
 });
 // `"cancelled"` is a clean termination, not a mid-stream failure: the
 // stream ended on purpose because the request was aborted, just not at
@@ -55,22 +56,22 @@ const rawOutputSchema = z.object({
 // client-side `CompletionRun` (`final` / `text` / `toolCalls` / `stats`)
 // reject with `InferenceCancelledError` carrying the partial state — see
 // `client/api/completion-stream.ts` for the rejection plumbing.
-const stopReasonEnum = z.enum(["eos", "length", "stopSequence", "cancelled"]);
+const stopReasonEnum = z.enum(['eos', 'length', 'stopSequence', 'cancelled']);
 const successDoneSchema = z
     .object({
-    type: z.literal("completionDone"),
+    type: z.literal('completionDone'),
     seq: seqSchema,
     stopReason: stopReasonEnum.optional(),
-    raw: rawOutputSchema.optional(),
+    raw: rawOutputSchema.optional()
 })
     .strict();
 const errorDoneSchema = z
     .object({
-    type: z.literal("completionDone"),
+    type: z.literal('completionDone'),
     seq: seqSchema,
-    stopReason: z.literal("error"),
+    stopReason: z.literal('error'),
     error: completionErrorSchema,
-    raw: rawOutputSchema.optional(),
+    raw: rawOutputSchema.optional()
 })
     .strict();
 export const doneEventSchema = z.union([errorDoneSchema, successDoneSchema]);
@@ -82,9 +83,9 @@ export const completionEventSchema = z.union([
     toolErrorEventSchema,
     statsEventSchema,
     errorDoneSchema,
-    successDoneSchema,
+    successDoneSchema
 ]);
 export const DEFAULT_PLUGIN_CAPABILITIES = {
-    toolCalling: "none",
-    thinkingFraming: "none",
+    toolCalling: 'none',
+    thinkingFraming: 'none'
 };

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

@@ -1,5 +1,5 @@
-import { z } from "zod";
-export { completionStatsSchema, type CompletionStats, } from "./completion-event";
+import { z } from 'zod';
+export { completionStatsSchema, type CompletionStats } from './completion-event';
 /**
  * Tool-call output dialect. Auto-detected from the model name; pass via
  * `completion({ toolDialect })` to override.
@@ -243,9 +243,10 @@ export declare const completionStreamResponseSchema: z.ZodObject<{
             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<{
-                cpu: "cpu";
                 gpu: "gpu";
+                cpu: "cpu";
             }>>;
         }, z.core.$strip>;
     }, z.core.$strip>, z.ZodObject<{

package/dist/schemas/completion-stream.js

@@ -1,8 +1,8 @@
-import { z } from "zod";
-import { toolSchema } from "./tools.js";
-import { completionEventSchema } from "./completion-event.js";
-import { REASONING_BUDGET_MAX } from "./llamacpp-config.js";
-export { completionStatsSchema, } from "./completion-event.js";
+import { z } from 'zod';
+import { toolSchema } from './tools.js';
+import { completionEventSchema } from './completion-event.js';
+import { REASONING_BUDGET_MAX } from './llamacpp-config.js';
+export { completionStatsSchema } from './completion-event.js';
 /**
  * Tool-call output dialect. Auto-detected from the model name; pass via
  * `completion({ toolDialect })` to override.
@@ -16,53 +16,41 @@ export { completionStatsSchema, } from "./completion-event.js";
  * - `"gemma4"`:   `<|tool_call>call:NAME{key:<|"|>val<|"|>,...}<tool_call|>`
  */
 export const toolDialectSchema = z.enum([
-    "hermes",
-    "pythonic",
-    "json",
-    "harmony",
-    "qwen35",
-    "gemma4"
+    'hermes',
+    'pythonic',
+    'json',
+    'harmony',
+    'qwen35',
+    'gemma4'
 ]);
 export const attachmentSchema = z.object({
     path: z
         .string()
-        .describe("Absolute or SDK-resolvable path to the attachment file (e.g., image for multimodal models)."),
+        .describe('Absolute or SDK-resolvable path to the attachment file (e.g., image for multimodal models).')
 });
 const kvCacheSchema = z.union([
     z.boolean(),
-    z.string().min(1, "KV cache key cannot be empty string"),
+    z.string().min(1, 'KV cache key cannot be empty string')
 ]);
 export const generationParamsSchema = z
     .object({
-    temp: z
-        .number()
-        .optional()
-        .describe("Sampling temperature (typically 0–2)."),
-    top_p: z
-        .number()
-        .optional()
-        .describe("Top-p (nucleus) sampling cutoff (0–1)."),
-    top_k: z
-        .number()
-        .optional()
-        .describe("Top-k sampling — keep only the top K tokens."),
+    temp: z.number().optional().describe('Sampling temperature (typically 0–2).'),
+    top_p: z.number().optional().describe('Top-p (nucleus) sampling cutoff (0–1).'),
+    top_k: z.number().optional().describe('Top-k sampling — keep only the top K tokens.'),
     predict: z
         .number()
         .optional()
-        .describe("Max tokens to predict. `-1` = until stop token, `-2` = until context filled."),
-    seed: z.number().optional().describe("Random seed for reproducibility."),
+        .describe('Max tokens to predict. `-1` = until stop token, `-2` = until context filled.'),
+    seed: z.number().optional().describe('Random seed for reproducibility.'),
     frequency_penalty: z
         .number()
         .optional()
-        .describe("Penalty applied to tokens based on frequency so far."),
+        .describe('Penalty applied to tokens based on frequency so far.'),
     presence_penalty: z
         .number()
         .optional()
-        .describe("Penalty applied to tokens that have already appeared."),
-    repeat_penalty: z
-        .number()
-        .optional()
-        .describe("Penalty applied to repeated tokens."),
+        .describe('Penalty applied to tokens that have already appeared.'),
+    repeat_penalty: z.number().optional().describe('Penalty applied to repeated tokens.'),
     reasoning_budget: z
         .number()
         .int()
@@ -73,110 +61,106 @@ 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`. 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.')
 })
     .strict();
 const jsonSchemaObjectSchema = z.record(z.string(), z.unknown());
-export const responseFormatSchema = z.discriminatedUnion("type", [
-    z.object({ type: z.literal("text") }).strict(),
-    z.object({ type: z.literal("json_object") }).strict(),
+export const responseFormatSchema = z.discriminatedUnion('type', [
+    z.object({ type: z.literal('text') }).strict(),
+    z.object({ type: z.literal('json_object') }).strict(),
     z
         .object({
-        type: z.literal("json_schema"),
+        type: z.literal('json_schema'),
         json_schema: z
             .object({
             name: z
                 .string()
                 .min(1)
-                .describe("Schema identifier; OpenAI-compatibility only — not used by the addon."),
+                .describe('Schema identifier; OpenAI-compatibility only — not used by the addon.'),
             description: z
                 .string()
                 .optional()
-                .describe("Free-form schema description. Accepted for OpenAI compatibility only — not forwarded to the addon and does not affect generation."),
+                .describe('Free-form schema description. Accepted for OpenAI compatibility only — not forwarded to the addon and does not affect generation.'),
             schema: jsonSchemaObjectSchema.describe("JSON Schema the model output must validate against. Forwarded to the addon as-is and converted to GBNF natively by llama.cpp's `json_schema_to_grammar()`."),
             strict: z
                 .boolean()
                 .optional()
-                .describe("Accepted for OpenAI compatibility but does NOT trigger OpenAI's auto-tightening semantics (implicit `additionalProperties: false`, all properties required). The schema is forwarded to the addon verbatim, so callers wanting strict validation must encode it explicitly in `schema`."),
+                .describe("Accepted for OpenAI compatibility but does NOT trigger OpenAI's auto-tightening semantics (implicit `additionalProperties: false`, all properties required). The schema is forwarded to the addon verbatim, so callers wanting strict validation must encode it explicitly in `schema`.")
         })
-            .strict(),
+            .strict()
     })
-        .strict(),
+        .strict()
 ]);
 export const completionParamsSchema = z.object({
     history: z
         .array(z.object({
-        role: z
-            .string()
-            .describe('Message role (e.g., `"user"`, `"assistant"`, `"system"`).'),
-        content: z.string().describe("Message content."),
+        role: z.string().describe('Message role (e.g., `"user"`, `"assistant"`, `"system"`).'),
+        content: z.string().describe('Message content.'),
         attachments: z
             .array(attachmentSchema)
             .optional()
-            .describe("Optional file attachments for multimodal models."),
+            .describe('Optional file attachments for multimodal models.')
     }))
-        .describe("Array of conversation messages sent to the model."),
-    modelId: z
-        .string()
-        .describe("The identifier of the model to use for completion."),
+        .describe('Array of conversation messages sent to the model.'),
+    modelId: z.string().describe('The identifier of the model to use for completion.'),
     kvCache: kvCacheSchema
         .optional()
-        .describe("KV cache configuration — `true` to auto-generate a cache key from history, a string to use a custom key, or `false`/`undefined` to disable."),
+        .describe('KV cache configuration — `true` to auto-generate a cache key from history, a string to use a custom key, or `false`/`undefined` to disable.')
 });
 const completionClientParamsBaseSchema = completionParamsSchema.extend({
     tools: z
         .array(toolSchema)
         .optional()
-        .describe("Optional array of tools (full `Tool` objects or Zod-schema `ToolInput` definitions) the model can call."),
+        .describe('Optional array of tools (full `Tool` objects or Zod-schema `ToolInput` definitions) the model can call.'),
     stream: z
         .boolean()
-        .describe("Whether to stream tokens (`true`) or return the complete response once (`false`)."),
+        .describe('Whether to stream tokens (`true`) or return the complete response once (`false`).'),
     kvCache: kvCacheSchema.optional(),
     generationParams: generationParamsSchema
         .optional()
-        .describe("Optional sampling / generation parameters."),
+        .describe('Optional sampling / generation parameters.'),
     captureThinking: z
         .boolean()
         .optional()
-        .describe("When `true`, capture and emit reasoning/thinking deltas separately from content deltas; requires a model that frames its thinking output."),
+        .describe('When `true`, capture and emit reasoning/thinking deltas separately from content deltas; requires a model that frames its thinking output.'),
     emitRawDeltas: z
         .boolean()
         .optional()
-        .describe("When `true`, also emit raw per-token deltas in the event stream in addition to normalized `contentDelta` events."),
+        .describe('When `true`, also emit raw per-token deltas in the event stream in addition to normalized `contentDelta` events.'),
     toolDialect: toolDialectSchema
         .optional()
         .describe("Override auto-detected tool-call dialect. Use when the SDK's name-based detection picks the wrong parser chain for your model."),
     responseFormat: responseFormatSchema
         .optional()
-        .describe("Optional structured-output constraint: `text` (default, free-form), `json_object` (any valid JSON), or `json_schema` (output conforms to the provided JSON Schema). Mutually exclusive with `tools`."),
+        .describe('Optional structured-output constraint: `text` (default, free-form), `json_object` (any valid JSON), or `json_schema` (output conforms to the provided JSON Schema). Mutually exclusive with `tools`.'),
     requestId: z
         .string()
         .min(1)
         .optional()
-        .describe("Stable identifier for this in-flight request, generated by the client at call time (opaque token, UUIDv4 when available). Surfaced on the `CompletionRun` result so callers can target it with `cancel({ requestId })`. Optional on the wire so legacy clients keep working — the server falls back to a server-generated id when the field is missing. Note: cancel-by-requestId only takes effect once the server has begun the request, so a cancel issued in the same tick as `completion()` may arrive before the request is registered."),
+        .describe('Stable identifier for this in-flight request, generated by the client at call time (opaque token, UUIDv4 when available). Surfaced on the `CompletionRun` result so callers can target it with `cancel({ requestId })`. Optional on the wire so legacy clients keep working — the server falls back to a server-generated id when the field is missing. Note: cancel-by-requestId only takes effect once the server has begun the request, so a cancel issued in the same tick as `completion()` may arrive before the request is registered.')
 });
 function refineNoToolsWithStructuredOutput(data, ctx) {
     if (data.responseFormat &&
-        data.responseFormat.type !== "text" &&
+        data.responseFormat.type !== 'text' &&
         data.tools &&
         data.tools.length > 0) {
         ctx.addIssue({
-            code: "custom",
-            message: "responseFormat (json_object/json_schema) cannot be combined with tools; tools already constrain output via their parameter schema.",
-            path: ["responseFormat"],
+            code: 'custom',
+            message: 'responseFormat (json_object/json_schema) cannot be combined with tools; tools already constrain output via their parameter schema.',
+            path: ['responseFormat']
         });
     }
 }
 export const completionClientParamsSchema = completionClientParamsBaseSchema.superRefine(refineNoToolsWithStructuredOutput);
 export const completionStreamRequestSchema = completionClientParamsBaseSchema
     .extend({
-    type: z.literal("completionStream"),
+    type: z.literal('completionStream')
 })
     .superRefine(refineNoToolsWithStructuredOutput);
 export const completionStreamResponseSchema = z
     .object({
-    type: z.literal("completionStream"),
+    type: z.literal('completionStream'),
     done: z.boolean().optional(),
-    events: z.array(completionEventSchema),
+    events: z.array(completionEventSchema)
 })
     .strict();

package/dist/schemas/delegate.d.ts

@@ -1,4 +1,4 @@
-import { z } from "zod";
+import { z } from 'zod';
 export declare const delegateBaseSchema: z.ZodObject<{
     providerPublicKey: z.ZodString;
     timeout: z.ZodOptional<z.ZodNumber>;

package/dist/schemas/delegate.js

@@ -1,20 +1,20 @@
-import { z } from "zod";
+import { z } from 'zod';
 const HYPERSWARM_PUBLIC_KEY_HEX = /^[0-9a-fA-F]{64}$/;
 export const delegateBaseSchema = z.object({
     providerPublicKey: z
         .string()
-        .regex(HYPERSWARM_PUBLIC_KEY_HEX, "providerPublicKey must be a 64-character hex string (32-byte ed25519 public key)")
-        .describe("Hex-encoded public key of the remote provider to delegate to."),
+        .regex(HYPERSWARM_PUBLIC_KEY_HEX, 'providerPublicKey must be a 64-character hex string (32-byte ed25519 public key)')
+        .describe('Hex-encoded public key of the remote provider to delegate to.'),
     timeout: z
         .number()
         .min(100)
         .optional()
-        .describe("Per-call timeout in milliseconds for the delegated request."),
+        .describe('Per-call timeout in milliseconds for the delegated request.'),
     healthCheckTimeout: z
         .number()
         .min(100)
         .optional()
-        .describe("Timeout in milliseconds for the health-check probe before delegating."),
+        .describe('Timeout in milliseconds for the health-check probe before delegating.')
 });
 export const delegateSchema = delegateBaseSchema
     .extend({
@@ -22,11 +22,11 @@ export const delegateSchema = delegateBaseSchema
         .boolean()
         .optional()
         .default(false)
-        .describe("When `true`, fall back to local execution if the delegated provider is unreachable."),
+        .describe('When `true`, fall back to local execution if the delegated provider is unreachable.'),
     forceNewConnection: z
         .boolean()
         .optional()
         .default(false)
-        .describe("When `true`, skip any cached delegation connection and open a fresh one."),
+        .describe('When `true`, skip any cached delegation connection and open a fresh one.')
 })
     .optional();

package/dist/schemas/delete-cache.d.ts

@@ -1,4 +1,4 @@
-import { z } from "zod";
+import { z } from 'zod';
 export declare const deleteCacheRequestSchema: z.ZodUnion<readonly [z.ZodObject<{
     type: z.ZodLiteral<"deleteCache">;
     all: z.ZodLiteral<true>;

package/dist/schemas/delete-cache.js

@@ -1,17 +1,17 @@
-import { z } from "zod";
+import { z } from 'zod';
 export const deleteCacheRequestSchema = z.union([
     z.object({
-        type: z.literal("deleteCache"),
-        all: z.literal(true),
+        type: z.literal('deleteCache'),
+        all: z.literal(true)
     }),
     z.object({
-        type: z.literal("deleteCache"),
+        type: z.literal('deleteCache'),
         kvCacheKey: z.string(),
-        modelId: z.string().optional(),
-    }),
+        modelId: z.string().optional()
+    })
 ]);
 export const deleteCacheResponseSchema = z.object({
-    type: z.literal("deleteCache"),
+    type: z.literal('deleteCache'),
     success: z.boolean(),
-    error: z.string().optional(),
+    error: z.string().optional()
 });

package/dist/schemas/download-asset.d.ts

@@ -1,5 +1,5 @@
-import { z } from "zod";
-import type { ModelProgressUpdate } from "./load-model";
+import { z } from 'zod';
+import type { ModelProgressUpdate } from './load-model';
 export declare const downloadAssetOptionsSchema: z.ZodPipe<z.ZodObject<{
     assetSrc: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
         src: z.ZodString;

package/dist/schemas/download-asset.js

@@ -1,25 +1,25 @@
-import { z } from "zod";
-import { modelSrcInputSchema, modelInputToSrcSchema } from "./model-src-utils.js";
+import { z } from 'zod';
+import { modelSrcInputSchema, modelInputToSrcSchema } from './model-src-utils.js';
 const downloadAssetOptionsBaseSchema = z.object({
     assetSrc: modelSrcInputSchema,
-    seed: z.boolean().optional(),
+    seed: z.boolean().optional()
 });
 export const downloadAssetOptionsSchema = downloadAssetOptionsBaseSchema.transform((data) => ({
     ...data,
-    seed: data.seed ?? false,
+    seed: data.seed ?? false
 }));
 export const downloadAssetOptionsToRequestSchema = downloadAssetOptionsBaseSchema
     .extend({
     onProgress: z.unknown().optional(),
     withProgress: z.boolean().optional(),
-    requestId: z.string().min(1).optional(),
+    requestId: z.string().min(1).optional()
 })
     .transform((data) => {
     const out = {
-        type: "downloadAsset",
+        type: 'downloadAsset',
         assetSrc: modelInputToSrcSchema.parse(data.assetSrc),
         withProgress: data.withProgress ?? !!data.onProgress,
-        seed: data.seed ?? false,
+        seed: data.seed ?? false
     };
     if (data.requestId !== undefined)
         out.requestId = data.requestId;
@@ -27,7 +27,7 @@ export const downloadAssetOptionsToRequestSchema = downloadAssetOptionsBaseSchem
 });
 export const downloadAssetRequestSchema = z
     .object({
-    type: z.literal("downloadAsset"),
+    type: z.literal('downloadAsset'),
     assetSrc: z.string(),
     withProgress: z.boolean().optional(),
     seed: z.boolean().optional(),
@@ -35,37 +35,37 @@ export const downloadAssetRequestSchema = z
         .string()
         .min(1)
         .optional()
-        .describe("Stable identifier for this in-flight download, generated by the client at call time. Optional on the wire so legacy clients keep working — the server falls back to a server-generated id when the field is missing. Exposed on the client-side decorated promise so callers can target this download with `cancel({ requestId })`."),
+        .describe('Stable identifier for this in-flight download, generated by the client at call time. Optional on the wire so legacy clients keep working — the server falls back to a server-generated id when the field is missing. Exposed on the client-side decorated promise so callers can target this download with `cancel({ requestId })`.')
 })
     .transform((data) => ({
     ...data,
-    seed: data.seed ?? false,
+    seed: data.seed ?? false
 }));
 export const downloadAssetResponseSchema = z.object({
-    type: z.literal("downloadAsset"),
+    type: z.literal('downloadAsset'),
     success: z.boolean(),
     assetId: z.string().optional(),
-    error: z.string().optional(),
+    error: z.string().optional()
 });
-const downloadTypes = ["hyperdrive", "http", "registry"];
+const downloadTypes = ['hyperdrive', 'http', 'registry'];
 export const downloadTypeSchema = z.enum(downloadTypes);
-export const sourceTypeSchema = z.enum([...downloadTypes, "filesystem"]);
+export const sourceTypeSchema = z.enum([...downloadTypes, 'filesystem']);
 export const downloadMetadataSchema = z.object({
     key: z.string(),
     startTime: z.number(),
-    type: downloadTypeSchema,
+    type: downloadTypeSchema
 });
 export const hyperdriveDownloadMetadataSchema = downloadMetadataSchema.extend({
-    type: z.literal("hyperdrive"),
+    type: z.literal('hyperdrive'),
     hyperdriveKey: z.string(),
-    modelFileName: z.string(),
+    modelFileName: z.string()
 });
 export const httpDownloadMetadataSchema = downloadMetadataSchema.extend({
-    type: z.literal("http"),
+    type: z.literal('http'),
     url: z.url(),
-    modelPath: z.string(),
+    modelPath: z.string()
 });
 export const registryDownloadMetadataSchema = downloadMetadataSchema.extend({
-    type: z.literal("registry"),
-    registryPath: z.string(),
+    type: z.literal('registry'),
+    registryPath: z.string()
 });

package/dist/schemas/embed.d.ts

@@ -1,4 +1,4 @@
-import { z } from "zod";
+import { z } from 'zod';
 export declare const embedParamsSchema: z.ZodObject<{
     modelId: z.ZodString;
     text: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
@@ -14,8 +14,8 @@ export declare const embedStatsSchema: z.ZodObject<{
     tokensPerSecond: z.ZodOptional<z.ZodNumber>;
     totalTokens: z.ZodOptional<z.ZodNumber>;
     backendDevice: z.ZodOptional<z.ZodEnum<{
-        cpu: "cpu";
         gpu: "gpu";
+        cpu: "cpu";
     }>>;
     contextSize: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
@@ -28,8 +28,8 @@ export declare const embedResponseSchema: z.ZodObject<{
         tokensPerSecond: z.ZodOptional<z.ZodNumber>;
         totalTokens: z.ZodOptional<z.ZodNumber>;
         backendDevice: z.ZodOptional<z.ZodEnum<{
-            cpu: "cpu";
             gpu: "gpu";
+            cpu: "cpu";
         }>>;
         contextSize: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>>;

package/dist/schemas/embed.js

@@ -1,46 +1,35 @@
-import { z } from "zod";
+import { z } from 'zod';
 export const embedParamsSchema = z.object({
-    modelId: z.string().describe("The identifier of the embedding model to use"),
+    modelId: z.string().describe('The identifier of the embedding model to use'),
     text: z
         .union([
-        z.string().min(1, "Text cannot be empty"),
-        z
-            .array(z.string().min(1, "Text cannot be empty"))
-            .min(1, "Text array cannot be empty"),
+        z.string().min(1, 'Text cannot be empty'),
+        z.array(z.string().min(1, 'Text cannot be empty')).min(1, 'Text array cannot be empty')
     ])
-        .describe("The input text(s) to embed. A single string returns `number[]`; an array returns `number[][]`."),
+        .describe('The input text(s) to embed. A single string returns `number[]`; an array returns `number[][]`.')
 });
 export const embedRequestSchema = embedParamsSchema.extend({
-    type: z.literal("embed"),
+    type: z.literal('embed'),
     requestId: z
         .string()
         .min(1)
         .optional()
-        .describe("Stable identifier for this in-flight embed, 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."),
+        .describe('Stable identifier for this in-flight embed, 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.')
 });
 export const embedStatsSchema = z.object({
-    totalTime: z
-        .number()
-        .optional()
-        .describe("Total embedding time in milliseconds"),
-    tokensPerSecond: z
-        .number()
-        .optional()
-        .describe("Tokens processed per second"),
-    totalTokens: z.number().optional().describe("Total tokens processed"),
-    backendDevice: z
-        .enum(["cpu", "gpu"])
-        .optional()
-        .describe("Compute backend used for inference"),
-    contextSize: z.number().optional().describe("Context size in tokens"),
+    totalTime: z.number().optional().describe('Total embedding time in milliseconds'),
+    tokensPerSecond: z.number().optional().describe('Tokens processed per second'),
+    totalTokens: z.number().optional().describe('Total tokens processed'),
+    backendDevice: z.enum(['cpu', 'gpu']).optional().describe('Compute backend used for inference'),
+    contextSize: z.number().optional().describe('Context size in tokens')
 });
 export const embedResponseSchema = z.object({
-    type: z.literal("embed"),
+    type: z.literal('embed'),
     success: z.boolean(),
     embedding: z
         .union([z.array(z.number()), z.array(z.array(z.number()))])
         .default([])
-        .describe("The embedding vector(s). Single `number[]` when `text` is a string; `number[][]` when `text` is an array."),
-    stats: embedStatsSchema.optional().describe("Performance statistics"),
-    error: z.string().optional(),
+        .describe('The embedding vector(s). Single `number[]` when `text` is a string; `number[][]` when `text` is an array.'),
+    stats: embedStatsSchema.optional().describe('Performance statistics'),
+    error: z.string().optional()
 });