@qvac/sdk 0.18.2 → 0.19.0

package/dist/schemas/common.js

@@ -1,138 +0,0 @@
-import { z } from 'zod';
-import { perCallProfilingSchema } from './profiling.js';
-import { heartbeatRequestSchema, heartbeatResponseSchema } from './heartbeat.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';
-import { unloadModelRequestSchema, unloadModelResponseSchema } from './unload-model.js';
-import { transcribeRequestSchema, transcribeResponseSchema, transcribeStreamRequestSchema, transcribeStreamResponseSchema } from './transcription.js';
-import { bciTranscribeRequestSchema, bciTranscribeResponseSchema, bciTranscribeStreamRequestSchema, bciTranscribeStreamResponseSchema } from './bci.js';
-import { embedRequestSchema, embedResponseSchema } from './embed.js';
-import { cancelRequestSchema, cancelResponseSchema } from './cancel.js';
-import { provideRequestSchema, provideResponseSchema } from './provide.js';
-import { stopProvideRequestSchema, stopProvideResponseSchema } from './stop-provide.js';
-import { translateRequestSchema, translateResponseSchema } from './translate.js';
-import { loggingStreamRequestSchema, loggingStreamResponseSchema } from './logging-stream.js';
-import { ttsRequestSchema, ttsResponseSchema, textToSpeechStreamRequestSchema, textToSpeechStreamResponseSchema } from './text-to-speech.js';
-import { errorResponseSchema } from './error.js';
-import { ragRequestSchema, ragResponseSchema, ragProgressUpdateSchema } from './rag.js';
-import { deleteCacheRequestSchema, deleteCacheResponseSchema } from './delete-cache.js';
-import { getModelInfoRequestSchema, getModelInfoResponseSchema } from './get-model-info.js';
-import { getLoadedModelInfoRequestSchema, getLoadedModelInfoResponseSchema } from './get-loaded-model-info.js';
-import { ocrStreamRequestSchema, ocrStreamResponseSchema } from './ocr.js';
-import { diffusionStreamRequestSchema, diffusionStreamResponseSchema, videoStreamRequestSchema, videoStreamResponseSchema, upscaleStreamRequestSchema, upscaleStreamResponseSchema } from './sdcpp-config.js';
-import { finetuneRequestSchema, finetuneResponseSchema, finetuneProgressResponseSchema } from './finetune.js';
-import { pluginInvokeRequestSchema, pluginInvokeResponseSchema, pluginInvokeStreamRequestSchema, pluginInvokeStreamResponseSchema } from './plugin.js';
-import { modelRegistryListRequestSchema, modelRegistryListResponseSchema, modelRegistrySearchRequestSchema, modelRegistrySearchResponseSchema, modelRegistryGetModelRequestSchema, modelRegistryGetModelResponseSchema } from './registry.js';
-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,
-    transcribeStreamRequestSchema,
-    bciTranscribeRequestSchema,
-    bciTranscribeStreamRequestSchema,
-    loggingStreamRequestSchema,
-    embedRequestSchema,
-    translateRequestSchema,
-    ttsRequestSchema,
-    textToSpeechStreamRequestSchema,
-    cancelRequestSchema,
-    provideRequestSchema,
-    stopProvideRequestSchema,
-    ragRequestSchema,
-    deleteCacheRequestSchema,
-    getModelInfoRequestSchema,
-    getLoadedModelInfoRequestSchema,
-    ocrStreamRequestSchema,
-    diffusionStreamRequestSchema,
-    videoStreamRequestSchema,
-    upscaleStreamRequestSchema,
-    finetuneRequestSchema,
-    pluginInvokeRequestSchema,
-    pluginInvokeStreamRequestSchema,
-    modelRegistryListRequestSchema,
-    modelRegistrySearchRequestSchema,
-    modelRegistryGetModelRequestSchema,
-    suspendRequestSchema,
-    resumeRequestSchema,
-    stateRequestSchema,
-    getSystemResourcesRequestSchema,
-    classifyRequestSchema
-]);
-export const responseSchema = z.discriminatedUnion('type', [
-    audioGenStreamResponseSchema,
-    heartbeatResponseSchema,
-    loadModelResponseSchema,
-    downloadAssetResponseSchema,
-    completionStreamResponseSchema,
-    completionOrchestrateResponseSchema,
-    batchCompletionStreamResponseSchema,
-    unloadModelResponseSchema,
-    modelProgressUpdateSchema,
-    transcribeResponseSchema,
-    transcribeStreamResponseSchema,
-    bciTranscribeResponseSchema,
-    bciTranscribeStreamResponseSchema,
-    loggingStreamResponseSchema,
-    embedResponseSchema,
-    translateResponseSchema,
-    ttsResponseSchema,
-    textToSpeechStreamResponseSchema,
-    cancelResponseSchema,
-    provideResponseSchema,
-    stopProvideResponseSchema,
-    errorResponseSchema,
-    ragResponseSchema,
-    ragProgressUpdateSchema,
-    deleteCacheResponseSchema,
-    getModelInfoResponseSchema,
-    getLoadedModelInfoResponseSchema,
-    ocrStreamResponseSchema,
-    diffusionStreamResponseSchema,
-    videoStreamResponseSchema,
-    upscaleStreamResponseSchema,
-    finetuneResponseSchema,
-    finetuneProgressResponseSchema,
-    pluginInvokeResponseSchema,
-    pluginInvokeStreamResponseSchema,
-    modelRegistryListResponseSchema,
-    modelRegistrySearchResponseSchema,
-    modelRegistryGetModelResponseSchema,
-    suspendResponseSchema,
-    resumeResponseSchema,
-    stateResponseSchema,
-    getSystemResourcesResponseSchema,
-    classifyResponseSchema
-]);
-export const rpcOptionsSchema = z.object({
-    timeout: z
-        .number()
-        .min(100)
-        .optional()
-        .describe('Per-call RPC timeout in milliseconds; overrides the SDK-level default for this request only.'),
-    healthCheckTimeout: z
-        .number()
-        .min(100)
-        .optional()
-        .describe('Timeout in milliseconds for the health-check probe that precedes the RPC call.'),
-    forceNewConnection: z
-        .boolean()
-        .optional()
-        .describe('When `true`, skip any cached RPC connection and open a fresh one for this call.'),
-    profiling: perCallProfilingSchema
-        .optional()
-        .describe("Per-call profiler configuration; when present, overrides the SDK's global profiler settings for this request.")
-});

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

@@ -1,249 +0,0 @@
-import { z } from 'zod';
-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";
-        cpu: "cpu";
-    }>>;
-}, z.core.$strip>;
-export type CompletionStats = z.infer<typeof completionStatsSchema>;
-export declare const seqSchema: z.ZodNumber;
-export declare const contentDeltaEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"contentDelta">;
-    seq: z.ZodNumber;
-    text: z.ZodString;
-}, z.core.$strip>;
-export declare const rawDeltaEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"rawDelta">;
-    seq: z.ZodNumber;
-    text: z.ZodString;
-}, z.core.$strip>;
-export declare const thinkingDeltaEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"thinkingDelta">;
-    seq: z.ZodNumber;
-    text: z.ZodString;
-}, z.core.$strip>;
-export declare const toolCallEventSchema: 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>;
-export declare const toolErrorEventSchema: 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>;
-export declare const statsEventSchema: 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>;
-export declare const completionErrorSchema: z.ZodObject<{
-    message: z.ZodString;
-}, z.core.$strip>;
-declare const stopReasonEnum: z.ZodEnum<{
-    cancelled: "cancelled";
-    eos: "eos";
-    length: "length";
-    stopSequence: "stopSequence";
-}>;
-export declare const doneEventSchema: z.ZodUnion<readonly [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>]>;
-export declare const completionEventSchema: 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>]>;
-export type ContentDeltaEvent = z.infer<typeof contentDeltaEventSchema>;
-export type RawDeltaEvent = z.infer<typeof rawDeltaEventSchema>;
-export type ThinkingDeltaEvent = z.infer<typeof thinkingDeltaEventSchema>;
-export type ToolCallEvent = z.infer<typeof toolCallEventSchema>;
-export type ToolErrorEvent = z.infer<typeof toolErrorEventSchema>;
-export type StatsEvent = z.infer<typeof statsEventSchema>;
-export type CompletionError = z.infer<typeof completionErrorSchema>;
-export type DoneEvent = z.infer<typeof doneEventSchema>;
-export type CompletionEvent = z.infer<typeof completionEventSchema>;
-export type StopReason = z.infer<typeof stopReasonEnum>;
-export type CompletionFinal = {
-    contentText: string;
-    thinkingText?: string;
-    toolCalls: ToolCallWithCall[];
-    stats?: CompletionStats;
-    stopReason?: StopReason;
-    raw: {
-        fullText: string;
-    };
-    /**
-     * Canonical assistant text to push back into `history` for the next turn
-     * when using `kvCache: true` (auto-cache). Equals the assistant content
-     * the SDK persisted to the cache key on this turn, so re-using it
-     * verbatim guarantees a cache hit on the next call.
-     *
-     * Derived from `raw.fullText` (or `contentText` if the addon didn't
-     * emit raw text) by stripping `<think>` reasoning blocks and trimming
-     * surrounding whitespace — see `normalizeAssistantCacheContent`.
-     *
-     * Tool-call turns currently can't be auto-cached, so this
-     * field is omitted when `toolCalls.length > 0`.
-     */
-    cacheableAssistantContent?: string;
-};
-export type CompletionRun = {
-    /**
-     * Stable identifier for this run, generated client-side at call time
-     * (UUIDv4 when `crypto.randomUUID` is available, otherwise an opaque
-     * random hex token) and available synchronously the moment
-     * `completion(...)` returns. Pass it to `cancel({ requestId })` to
-     * target this specific request without affecting any other inference
-     * running on the same model. The cancel only takes effect once the
-     * server has begun the request, so a cancel issued in the same tick
-     * as `completion(...)` may race the begin and is logged as a no-match.
-     */
-    requestId: string;
-    /** Ordered stream of typed completion events — the canonical consumption API. */
-    events: AsyncIterable<CompletionEvent>;
-    /** Resolves when the stream ends with aggregated content, thinking, tool calls, stats, and raw output. */
-    final: Promise<CompletionFinal>;
-    tokenStream: AsyncGenerator<string>;
-    toolCallStream: AsyncGenerator<ToolCallEvent>;
-    text: Promise<string>;
-    toolCalls: Promise<ToolCallWithCall[]>;
-    stats: Promise<CompletionStats | undefined>;
-};
-export type ToolCallingCapability = 'textParse' | 'none';
-export type ThinkingFramingCapability = 'thinkTags' | 'none';
-export type PluginCapabilities = {
-    toolCalling: ToolCallingCapability;
-    thinkingFraming: ThinkingFramingCapability;
-};
-export declare const DEFAULT_PLUGIN_CAPABILITIES: PluginCapabilities;
-export type NormalizerConfig = {
-    capabilities: PluginCapabilities;
-    tools: Tool[];
-    captureThinking: boolean;
-    emitRawDeltas: boolean;
-    toolDialect?: ToolDialect;
-};
-export {};
-//# sourceMappingURL=completion-event.d.ts.map

package/dist/schemas/completion-event.js

@@ -1,94 +0,0 @@
-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(),
-    // 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()
-});
-export const seqSchema = z.number().int().nonnegative();
-export const contentDeltaEventSchema = z.object({
-    type: z.literal('contentDelta'),
-    seq: seqSchema,
-    text: z.string()
-});
-export const rawDeltaEventSchema = z.object({
-    type: z.literal('rawDelta'),
-    seq: seqSchema,
-    text: z.string()
-});
-export const thinkingDeltaEventSchema = z.object({
-    type: z.literal('thinkingDelta'),
-    seq: seqSchema,
-    text: z.string()
-});
-export const toolCallEventSchema = z.object({
-    type: z.literal('toolCall'),
-    seq: seqSchema,
-    call: toolCallSchema
-});
-export const toolErrorEventSchema = z.object({
-    type: z.literal('toolError'),
-    seq: seqSchema,
-    error: toolCallErrorSchema
-});
-export const statsEventSchema = z.object({
-    type: z.literal('completionStats'),
-    seq: seqSchema,
-    stats: completionStatsSchema
-});
-export const completionErrorSchema = z.object({
-    message: z.string()
-});
-const rawOutputSchema = z.object({
-    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
-// EOS. It rides the success-done path (alongside "eos" / "length" /
-// "stopSequence") so consumers iterating `events` see the stream end
-// naturally. The companion error path (`errorDoneSchema` below) keeps
-// `stopReason: "error"` for actual mid-stream failures where the
-// partial state is unsafe to use. The promise-aggregates on the
-// 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 successDoneSchema = z
-    .object({
-    type: z.literal('completionDone'),
-    seq: seqSchema,
-    stopReason: stopReasonEnum.optional(),
-    raw: rawOutputSchema.optional()
-})
-    .strict();
-const errorDoneSchema = z
-    .object({
-    type: z.literal('completionDone'),
-    seq: seqSchema,
-    stopReason: z.literal('error'),
-    error: completionErrorSchema,
-    raw: rawOutputSchema.optional()
-})
-    .strict();
-export const doneEventSchema = z.union([errorDoneSchema, successDoneSchema]);
-export const completionEventSchema = z.union([
-    contentDeltaEventSchema,
-    rawDeltaEventSchema,
-    thinkingDeltaEventSchema,
-    toolCallEventSchema,
-    toolErrorEventSchema,
-    statsEventSchema,
-    errorDoneSchema,
-    successDoneSchema
-]);
-export const DEFAULT_PLUGIN_CAPABILITIES = {
-    toolCalling: 'none',
-    thinkingFraming: 'none'
-};