@qvac/sdk 0.14.1 → 0.16.0

package/dist/server/rpc/handler-utils.d.ts

@@ -1,28 +1,28 @@
-import { type QvacConfig, type Request, type Response, type RuntimeContext } from "../../schemas/index";
-import type RPC from "bare-rpc";
-import { type ServerProfiler } from "./profiling/index";
+import { type QvacConfig, type Request, type Response, type RuntimeContext } from '../../schemas/index';
+import type RPC from 'bare-rpc';
+import { type ServerProfiler } from './profiling/index';
 type ReplyHandler = (request: any, ...args: any[]) => Promise<Response> | Response;
 type StreamHandler = (request: any, ...args: any[]) => AsyncGenerator<Response>;
 type ProgressHandler = (request: any, ...args: any[]) => Promise<Response>;
 type DuplexStreamHandler = (request: any, inputStream: any) => AsyncGenerator<Response>;
 export type HandlerEntry = {
-    type: "reply" | "stream" | "duplex";
+    type: 'reply' | 'stream' | 'duplex';
     handler: ReplyHandler | StreamHandler | ProgressHandler | DuplexStreamHandler;
     delegatedHandler?: ReplyHandler | StreamHandler | ProgressHandler | DuplexStreamHandler;
     isDelegated?: (request: Request) => boolean;
     supportsProgress?: boolean | ((request: Request) => boolean);
 };
-export declare function executeDuplexHandler(_req: RPC.IncomingRequest, request: Request, entry: HandlerEntry, inputStream: ReturnType<RPC.IncomingRequest["createRequestStream"]>, outputStream: ReturnType<RPC.IncomingRequest["createResponseStream"]>, profiler: ServerProfiler): Promise<void>;
+export declare function executeDuplexHandler(_req: RPC.IncomingRequest, request: Request, entry: HandlerEntry, inputStream: ReturnType<RPC.IncomingRequest['createRequestStream']>, outputStream: ReturnType<RPC.IncomingRequest['createResponseStream']>, profiler: ServerProfiler): Promise<void>;
 export declare function executeHandler(req: RPC.IncomingRequest, request: Request, entry: HandlerEntry, profiler: ServerProfiler): Promise<void>;
 type InitConfigMessage = {
-    type: "__init_config";
+    type: '__init_config';
     config: QvacConfig;
     runtimeContext?: RuntimeContext;
 };
 export declare function isInitConfigMessage(data: unknown): data is InitConfigMessage;
 export declare function handleInitConfig(req: RPC.IncomingRequest, data: InitConfigMessage): void;
 type ShutdownMessage = {
-    type: "__shutdown__";
+    type: '__shutdown__';
 };
 export declare function isShutdownMessage(data: unknown): data is ShutdownMessage;
 export declare function handleShutdown(req: RPC.IncomingRequest): Promise<void>;

package/dist/server/rpc/handler-utils.js

@@ -1,12 +1,12 @@
-import { PROFILING_KEY, } from "../../schemas/index.js";
-import { sendErrorResponse, sendStreamErrorResponse, } from "../error-handlers.js";
-import { PluginHandlerTypeMismatchError } from "../../utils/errors-server.js";
-import { setSDKConfig } from "../bare/registry/config-registry.js";
-import { setRuntimeContext } from "../bare/registry/runtime-context-registry.js";
-import {} from "./profiling/index.js";
-import { isTerminalChunk } from "./rpc-utils.js";
-import { createProgressThrottle } from "./progress-throttle.js";
-import { handlerSupportsProgress, selectHandler, } from "./handler-selection.js";
+import { PROFILING_KEY } from '../../schemas/index.js';
+import { sendErrorResponse, sendStreamErrorResponse } from '../error-handlers.js';
+import { PluginHandlerTypeMismatchError } from '../../utils/errors-server.js';
+import { setSDKConfig } from '../bare/registry/config-registry.js';
+import { setRuntimeContext } from '../bare/registry/runtime-context-registry.js';
+import {} from './profiling/index.js';
+import { isTerminalChunk } from './rpc-utils.js';
+import { createProgressThrottle } from './progress-throttle.js';
+import { handlerSupportsProgress, selectHandler } from './handler-selection.js';
 function getProfilingMetaFromRequest(request) {
     if (PROFILING_KEY in request) {
         return request[PROFILING_KEY];
@@ -25,7 +25,7 @@ async function executeReplyHandler(req, request, handler, profiler, isDelegated)
             response = await handler(request);
         }
         profiler.endHandler();
-        req.reply(profiler.serialize(response, true), "utf-8");
+        req.reply(profiler.serialize(response, true), 'utf-8');
     }
     catch (error) {
         profiler.endHandler();
@@ -49,11 +49,11 @@ async function executeStreamHandler(req, request, handler, profiler, isDelegated
         for await (const response of generator) {
             if (isTerminalChunk(response)) {
                 profiler.endHandler();
-                stream.write(profiler.serialize(response, true) + "\n", "utf-8");
+                stream.write(profiler.serialize(response, true) + '\n', 'utf-8');
                 sentFinalChunk = true;
             }
             else {
-                stream.write(profiler.serialize(response, false) + "\n", "utf-8");
+                stream.write(profiler.serialize(response, false) + '\n', 'utf-8');
             }
         }
         // Fallback
@@ -61,7 +61,7 @@ async function executeStreamHandler(req, request, handler, profiler, isDelegated
             profiler.endHandler();
             const trailer = profiler.serialize();
             if (trailer) {
-                stream.write(trailer + "\n", "utf-8");
+                stream.write(trailer + '\n', 'utf-8');
             }
         }
         stream.end();
@@ -75,8 +75,8 @@ async function executeProgressHandler(req, request, handler, profiler, isDelegat
     const stream = req.createResponseStream();
     profiler.startHandler();
     const writeBatch = (updates) => {
-        const payload = updates.map((u) => profiler.serialize(u, false)).join("\n");
-        stream.write(payload + "\n", "utf-8");
+        const payload = updates.map((u) => profiler.serialize(u, false)).join('\n');
+        stream.write(payload + '\n', 'utf-8');
     };
     const throttle = createProgressThrottle(writeBatch);
     try {
@@ -94,7 +94,7 @@ async function executeProgressHandler(req, request, handler, profiler, isDelegat
         }
         throttle.flush();
         profiler.endHandler();
-        stream.write(profiler.serialize(response, true) + "\n", "utf-8");
+        stream.write(profiler.serialize(response, true) + '\n', 'utf-8');
         stream.end();
     }
     catch (error) {
@@ -108,12 +108,12 @@ export async function executeDuplexHandler(_req, request, entry, inputStream, ou
     profiler.startHandler();
     try {
         for await (const response of handler(request, inputStream)) {
-            outputStream.write(profiler.serialize(response, false) + "\n", "utf-8");
+            outputStream.write(profiler.serialize(response, false) + '\n', 'utf-8');
         }
         profiler.endHandler();
         const trailer = profiler.serialize();
         if (trailer) {
-            outputStream.write(trailer + "\n", "utf-8");
+            outputStream.write(trailer + '\n', 'utf-8');
         }
         outputStream.end();
     }
@@ -126,10 +126,10 @@ export async function executeDuplexHandler(_req, request, entry, inputStream, ou
 export async function executeHandler(req, request, entry, profiler) {
     const { handler, isDelegated } = selectHandler(entry, request);
     const wantsProgress = handlerSupportsProgress(entry, request);
-    if (entry.type === "duplex") {
-        throw new PluginHandlerTypeMismatchError(request.type, "reply or stream", "duplex");
+    if (entry.type === 'duplex') {
+        throw new PluginHandlerTypeMismatchError(request.type, 'reply or stream', 'duplex');
     }
-    if (entry.type === "stream") {
+    if (entry.type === 'stream') {
         await executeStreamHandler(req, request, handler, profiler, isDelegated);
     }
     else if (wantsProgress) {
@@ -140,10 +140,7 @@ export async function executeHandler(req, request, entry, profiler) {
     }
 }
 export function isInitConfigMessage(data) {
-    return (typeof data === "object" &&
-        data !== null &&
-        "type" in data &&
-        data.type === "__init_config");
+    return (typeof data === 'object' && data !== null && 'type' in data && data.type === '__init_config');
 }
 export function handleInitConfig(req, data) {
     try {
@@ -153,34 +150,34 @@ export function handleInitConfig(req, data) {
         if (data.runtimeContext) {
             setRuntimeContext(data.runtimeContext);
         }
-        req.reply(JSON.stringify({ success: true }), "utf-8");
+        req.reply(JSON.stringify({ success: true }), 'utf-8');
     }
     catch (error) {
         req.reply(JSON.stringify({
             success: false,
-            error: error instanceof Error ? error.message : String(error),
-        }), "utf-8");
+            error: error instanceof Error ? error.message : String(error)
+        }), 'utf-8');
     }
 }
 export function isShutdownMessage(data) {
-    return (typeof data === "object" &&
+    return (typeof data === 'object' &&
         data !== null &&
-        "type" in data &&
-        data.type === "__shutdown__");
+        'type' in data &&
+        data.type === '__shutdown__');
 }
 export async function handleShutdown(req) {
     try {
         // Lazy import to avoid the import cycle:
         //   handler-utils -> worker-core -> create-server -> handle-request
         //   -> handler-utils. By the time this runs, all modules are loaded.
-        const { cleanupForTerminate } = await import("../worker-core.js");
+        const { cleanupForTerminate } = await import('../worker-core.js');
         await cleanupForTerminate();
-        req.reply(JSON.stringify({ success: true }), "utf-8");
+        req.reply(JSON.stringify({ success: true }), 'utf-8');
     }
     catch (error) {
         req.reply(JSON.stringify({
             success: false,
-            error: error instanceof Error ? error.message : String(error),
-        }), "utf-8");
+            error: error instanceof Error ? error.message : String(error)
+        }), 'utf-8');
     }
 }

package/dist/server/rpc/handlers/batch-completion-stream.d.ts

@@ -0,0 +1,78 @@
+import type { BatchCompletionStreamRequest } from '../../../schemas/index';
+export declare function handleBatchCompletionStream(request: BatchCompletionStreamRequest): AsyncGenerator<{
+    type: "batchCompletionStream";
+    events: {
+        id: string;
+        event: {
+            type: "contentDelta";
+            seq: number;
+            text: string;
+        } | {
+            type: "rawDelta";
+            seq: number;
+            text: string;
+        } | {
+            type: "thinkingDelta";
+            seq: number;
+            text: string;
+        } | {
+            type: "toolCall";
+            seq: number;
+            call: {
+                id: string;
+                name: string;
+                arguments: Record<string, unknown>;
+                raw?: string | undefined;
+            };
+        } | {
+            type: "toolError";
+            seq: number;
+            error: {
+                code: "PARSE_ERROR" | "VALIDATION_ERROR" | "UNKNOWN_TOOL";
+                message: string;
+                raw?: string | undefined;
+            };
+        } | {
+            type: "completionStats";
+            seq: number;
+            stats: {
+                timeToFirstToken?: number | undefined;
+                tokensPerSecond?: number | undefined;
+                cacheTokens?: number | undefined;
+                promptTokens?: number | undefined;
+                generatedTokens?: number | undefined;
+                avgConcurrentSeq?: number | undefined;
+                backendDevice?: "gpu" | "cpu" | undefined;
+            };
+        } | {
+            type: "completionDone";
+            seq: number;
+            stopReason: "error";
+            error: {
+                message: string;
+            };
+            raw?: {
+                fullText: string;
+            } | undefined;
+        } | {
+            type: "completionDone";
+            seq: number;
+            stopReason?: "cancelled" | "eos" | "length" | "stopSequence" | undefined;
+            raw?: {
+                fullText: string;
+            } | undefined;
+        };
+    }[];
+    done?: boolean | undefined;
+    ids?: string[] | undefined;
+    stats?: {
+        timeToFirstToken?: number | undefined;
+        tokensPerSecond?: number | undefined;
+        cacheTokens?: number | undefined;
+        promptTokens?: number | undefined;
+        generatedTokens?: number | undefined;
+        avgConcurrentSeq?: number | undefined;
+        backendDevice?: "gpu" | "cpu" | undefined;
+    } | undefined;
+}, void, any>;
+//# sourceMappingURL=batch-completion-stream.d.ts.map

package/dist/server/rpc/handlers/batch-completion-stream.js

@@ -0,0 +1,4 @@
+import { dispatchPluginStream } from './plugin-dispatch.js';
+export async function* handleBatchCompletionStream(request) {
+    yield* dispatchPluginStream(request.modelId, 'batchCompletionStream', request);
+}

package/dist/server/rpc/handlers/bci-transcribe-stream.d.ts

@@ -1,3 +1,3 @@
-import type { BciTranscribeStreamRequest, BciTranscribeStreamResponse } from "../../../schemas/index";
+import type { BciTranscribeStreamRequest, BciTranscribeStreamResponse } from '../../../schemas/index';
 export declare function handleBciTranscribeStream(request: BciTranscribeStreamRequest, inputStream: AsyncIterable<Buffer>): AsyncGenerator<BciTranscribeStreamResponse>;
 //# sourceMappingURL=bci-transcribe-stream.d.ts.map

package/dist/server/rpc/handlers/bci-transcribe-stream.js

@@ -1,4 +1,4 @@
-import { dispatchPluginStream } from "./plugin-dispatch.js";
+import { dispatchPluginStream } from './plugin-dispatch.js';
 export async function* handleBciTranscribeStream(request, inputStream) {
-    yield* dispatchPluginStream(request.modelId, "bciTranscribeStream", request, inputStream);
+    yield* dispatchPluginStream(request.modelId, 'bciTranscribeStream', request, inputStream);
 }

package/dist/server/rpc/handlers/bci-transcribe.d.ts

@@ -1,3 +1,3 @@
-import type { BciTranscribeRequest, BciTranscribeResponse } from "../../../schemas/index";
+import type { BciTranscribeRequest, BciTranscribeResponse } from '../../../schemas/index';
 export declare function handleBciTranscribe(request: BciTranscribeRequest): AsyncGenerator<BciTranscribeResponse>;
 //# sourceMappingURL=bci-transcribe.d.ts.map

package/dist/server/rpc/handlers/bci-transcribe.js

@@ -1,4 +1,4 @@
-import { dispatchPluginStream } from "./plugin-dispatch.js";
+import { dispatchPluginStream } from './plugin-dispatch.js';
 export async function* handleBciTranscribe(request) {
-    yield* dispatchPluginStream(request.modelId, "bciTranscribe", request);
+    yield* dispatchPluginStream(request.modelId, 'bciTranscribe', request);
 }

package/dist/server/rpc/handlers/cancel-delegated.d.ts

@@ -1,4 +1,4 @@
-import type { CancelRequest, CancelResponse } from "../../../schemas/cancel";
-import type { DelegatedHandlerOptions } from "../profiling/index";
+import type { CancelRequest, CancelResponse } from '../../../schemas/cancel';
+import type { DelegatedHandlerOptions } from '../profiling/index';
 export declare function handleCancelDelegated(request: CancelRequest, options?: DelegatedHandlerOptions): Promise<CancelResponse>;
 //# sourceMappingURL=cancel-delegated.d.ts.map

package/dist/server/rpc/handlers/cancel-delegated.js

@@ -1,7 +1,7 @@
-import { getServerLogger } from "../../../logging/index.js";
-import { getModelEntry } from "../../bare/registry/model-registry.js";
-import { getRPC } from "../../bare/delegate-rpc-client.js";
-import { send } from "../delegate-transport.js";
+import { getServerLogger } from '../../../logging/index.js';
+import { getModelEntry } from '../../bare/registry/model-registry.js';
+import { getRPC } from '../../bare/delegate-rpc-client.js';
+import { send } from '../delegate-transport.js';
 const logger = getServerLogger();
 /**
  * Resolve the delegated provider for a cancel request, if any.
@@ -20,13 +20,13 @@ const logger = getServerLogger();
  * fire a broad cancel against the model id instead.
  */
 function resolveDelegationTarget(request) {
-    if (request.operation !== "broad")
+    if (request.operation !== 'broad')
         return null;
     const entry = getModelEntry(request.modelId);
     if (!entry?.isDelegated)
         return null;
     const target = {
-        providerPublicKey: entry.delegated.providerPublicKey,
+        providerPublicKey: entry.delegated.providerPublicKey
     };
     if (entry.delegated.timeout !== undefined) {
         target.timeout = entry.delegated.timeout;
@@ -37,14 +37,14 @@ export async function handleCancelDelegated(request, options) {
     const target = resolveDelegationTarget(request);
     if (!target) {
         logger.warn(`Delegated cancel skipped (no delegation target): operation=${request.operation}`);
-        return { type: "cancel", success: true };
+        return { type: 'cancel', success: true };
     }
     try {
         const rpc = await getRPC(target.providerPublicKey, {
-            timeout: target.timeout,
+            timeout: target.timeout
         });
         const delegateOpts = {
-            peerKey: target.providerPublicKey,
+            peerKey: target.providerPublicKey
         };
         if (target.timeout !== undefined) {
             delegateOpts.timeout = target.timeout;
@@ -53,14 +53,14 @@ export async function handleCancelDelegated(request, options) {
             delegateOpts.profilingMeta = options.profilingMeta;
         }
         await send(request, rpc, delegateOpts);
-        return { type: "cancel", success: true };
+        return { type: 'cancel', success: true };
     }
     catch (error) {
-        logger.error("Error during delegated cancellation:", error);
+        logger.error('Error during delegated cancellation:', error);
         return {
-            type: "cancel",
+            type: 'cancel',
             success: false,
-            error: error instanceof Error ? error.message : "Unknown error",
+            error: error instanceof Error ? error.message : 'Unknown error'
         };
     }
 }

package/dist/server/rpc/handlers/cancelHandler.d.ts

@@ -1,4 +1,4 @@
-import type { CancelRequest, CancelResponse } from "../../../schemas/cancel";
+import type { CancelRequest, CancelResponse } from '../../../schemas/cancel';
 /**
  * Cancel RPC entry point. The 5-arm `switch (request.operation)`
  * dispatcher that lived here through 0.10.x was retired in 0.11.0:

package/dist/server/rpc/handlers/cancelHandler.js

@@ -1,7 +1,7 @@
-import { cancel as cancelByModelId } from "../../bare/ops/cancel.js";
-import { getRequestRegistry } from "../../bare/runtime/index.js";
-import { markClearCacheForRequest } from "./load-model/download-manager.js";
-import { getServerLogger } from "../../../logging/index.js";
+import { cancel as cancelByModelId } from '../../bare/ops/cancel.js';
+import { getRequestRegistry } from '../../bare/runtime/index.js';
+import { markClearCacheForRequest } from './load-model/download-manager.js';
+import { getServerLogger } from '../../../logging/index.js';
 const logger = getServerLogger();
 /**
  * Cancel RPC entry point. The 5-arm `switch (request.operation)`
@@ -34,12 +34,12 @@ const logger = getServerLogger();
  */
 export function cancelHandler(request) {
     try {
-        if (request.operation === "request") {
+        if (request.operation === 'request') {
             if (request.clearCache) {
                 markClearCacheForRequest(request.requestId);
             }
             const cancelled = getRequestRegistry().cancel({
-                requestId: request.requestId,
+                requestId: request.requestId
             });
             if (cancelled === 0) {
                 // info-level (not debug) because the decorated-promise pattern
@@ -52,18 +52,18 @@ export function cancelHandler(request) {
                 // the log level.
                 logger.info(`[cancel] no in-flight request matched requestId=${request.requestId}`);
             }
-            return { type: "cancel", success: true, cancelled };
+            return { type: 'cancel', success: true, cancelled };
         }
         // operation === "broad"
         const cancelled = cancelByModelId({ modelId: request.modelId }, request.kind ? { kind: request.kind } : undefined);
-        return { type: "cancel", success: true, cancelled };
+        return { type: 'cancel', success: true, cancelled };
     }
     catch (error) {
-        logger.error("Error during cancellation:", error);
+        logger.error('Error during cancellation:', error);
         return {
-            type: "cancel",
+            type: 'cancel',
             success: false,
-            error: error instanceof Error ? error.message : "Unknown error",
+            error: error instanceof Error ? error.message : 'Unknown error'
         };
     }
 }

package/dist/server/rpc/handlers/classify.d.ts

@@ -1,3 +1,3 @@
-import type { ClassifyRequest, ClassifyResponse } from "../../../schemas/classification";
+import type { ClassifyRequest, ClassifyResponse } from '../../../schemas/classification';
 export declare function handleClassify(request: ClassifyRequest): AsyncGenerator<ClassifyResponse>;
 //# sourceMappingURL=classify.d.ts.map

package/dist/server/rpc/handlers/classify.js

@@ -1,4 +1,4 @@
-import { dispatchPluginStream } from "./plugin-dispatch.js";
+import { dispatchPluginStream } from './plugin-dispatch.js';
 export async function* handleClassify(request) {
-    yield* dispatchPluginStream(request.modelId, "classify", request);
+    yield* dispatchPluginStream(request.modelId, 'classify', request);
 }

package/dist/server/rpc/handlers/completion-orchestrate.d.ts

@@ -0,0 +1,42 @@
+import type { CompletionOrchestrateRequest, CompletionOrchestrateResponse, CompletionStreamRequest, CompletionStreamResponse } from '../../../schemas/index';
+import { type ToolCallbackResult } from '../../../schemas/completion-stream';
+/**
+ * Reads newline-delimited JSON tool results off the duplex request stream
+ * and resolves per-callId waiters. Chunk boundaries don't align with lines,
+ * so a partial tail is buffered until its newline arrives.
+ *
+ * The pump is torn down by `close()` (called from a `finally` when
+ * orchestration ends, however it ends) so the upstream iterator is returned
+ * and the reader stops holding the request stream open.
+ */
+export declare class ToolResultReader {
+    private buffer;
+    private readonly results;
+    private readonly waiters;
+    private failed;
+    private closed;
+    private readonly iterator;
+    constructor(inputStream: AsyncIterable<Buffer>);
+    private pump;
+    private failWaiters;
+    private accept;
+    waitFor(callId: string, timeoutMs?: number): Promise<ToolCallbackResult>;
+    /**
+     * Stop the pump and release the upstream iterator. Idempotent. Pending
+     * waiters are failed so a caller blocked in `waitFor` can't hang after the
+     * stream is torn down.
+     */
+    close(): void;
+}
+type RunTurn = (request: CompletionStreamRequest) => AsyncGenerator<CompletionStreamResponse, void, unknown>;
+/**
+ * The orchestration core, pure over its collaborators so it unit-tests
+ * without the plugin registry: runs completion turns, forwards their events
+ * downstream, and when a turn requests tool calls, emits `toolCallback`
+ * frames and blocks on the client's results before starting the next turn
+ * with the extended history.
+ */
+export declare function orchestrateCompletion(request: CompletionOrchestrateRequest, runTurn: RunTurn, reader: Pick<ToolResultReader, 'waitFor'>): AsyncGenerator<CompletionOrchestrateResponse>;
+export declare function handleCompletionOrchestrate(request: CompletionOrchestrateRequest, inputStream: AsyncIterable<Buffer>): AsyncGenerator<CompletionOrchestrateResponse>;
+export {};
+//# sourceMappingURL=completion-orchestrate.d.ts.map