@qvac/sdk 0.15.0 → 0.17.0

package/dist/server/bare/utils/audio-input.d.ts

@@ -1,5 +1,5 @@
 import { Readable } from 'bare-stream';
-import type { AudioInput, AudioFormat } from '../../../schemas/index';
+import type { AudioInput, AudioFormat } from '../../../schemas/index.js';
 /**
  * Converts an AudioInput (base64 or filePath) into a Readable stream,
  * decoding the audio when necessary.

package/dist/server/bare/utils/audio-input.js

@@ -1,6 +1,6 @@
 import { Readable } from 'bare-stream';
 import fs from 'bare-fs';
-import { needsDecoding, decodeAudioToStream } from '../../utils/audio/decoder.js';
+import { needsDecoding, decodeAudioToStream } from '../../../server/utils/audio/decoder.js';
 import { AudioFileNotFoundError, InvalidAudioChunkError } from '../../../utils/errors-server.js';
 /**
  * Converts an AudioInput (base64 or filePath) into a Readable stream,

package/dist/server/bare/utils/transcribe-metadata.d.ts

@@ -1,4 +1,4 @@
-import { type TranscribeSegment } from '../../../schemas/index';
+import { type TranscribeSegment } from '../../../schemas/index.js';
 export interface WhisperAddonSegment {
     text: string;
     start?: number;

package/dist/server/bare/utils/tts-stats.d.ts

@@ -1,4 +1,4 @@
-import type { TtsStats } from '../../../schemas/index';
+import type { TtsStats } from '../../../schemas/index.js';
 /**
  * Shared types and utilities for TTS operations.
  * Used by both text-to-speech.ts and text-to-speech-stream.ts.
@@ -13,10 +13,14 @@ export type TtsOpYield = {
     chunkIndex?: number;
     sentenceChunk?: string;
 };
+type AddonTtsStats = {
+    audioDurationMs?: number;
+    totalSamples?: number;
+    enhancerBackendDevice?: number;
+    enhancerBackendId?: number;
+};
 export declare function collectTtsStats(response: {
-    stats?: {
-        audioDurationMs?: number;
-        totalSamples?: number;
-    };
+    stats?: AddonTtsStats;
 }): TtsStats;
+export {};
 //# sourceMappingURL=tts-stats.d.ts.map

package/dist/server/bare/utils/tts-stats.js

@@ -5,6 +5,12 @@ export function collectTtsStats(response) {
         }),
         ...(response.stats?.totalSamples !== undefined && {
             totalSamples: response.stats.totalSamples
+        }),
+        ...(response.stats?.enhancerBackendDevice !== undefined && {
+            enhancerBackendDevice: response.stats.enhancerBackendDevice
+        }),
+        ...(response.stats?.enhancerBackendId !== undefined && {
+            enhancerBackendId: response.stats.enhancerBackendId
         })
     };
 }

package/dist/server/error-handlers.d.ts

@@ -1,5 +1,5 @@
 import type RPC from 'bare-rpc';
-import { type ServerProfiler } from './rpc/profiling/index';
+import { type ServerProfiler } from './rpc/profiling/index.js';
 export declare function sendErrorResponse(req: RPC.IncomingRequest, error: unknown, profiler?: ServerProfiler): void;
 export declare function sendStreamErrorResponse(stream: ReturnType<RPC.IncomingRequest['createResponseStream']>, error: unknown, profiler?: ServerProfiler): void;
 //# sourceMappingURL=error-handlers.d.ts.map

package/dist/server/plugins/index.d.ts

@@ -1,2 +1,2 @@
-export { registerPlugin, registerPlugins, getPlugin, getPluginHandler, hasPlugin, getAllPlugins, clearPlugins, unregisterPlugin } from './registry';
+export { registerPlugin, registerPlugins, getPlugin, getPluginHandler, hasPlugin, getAllPlugins, clearPlugins, unregisterPlugin } from './registry.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/server/plugins/registry.d.ts

@@ -1,4 +1,4 @@
-import { type QvacPlugin, type PluginHandlerDefinition } from '../../schemas/plugin';
+import { type QvacPlugin, type PluginHandlerDefinition } from '../../schemas/plugin.js';
 export declare function registerPlugin(plugin: QvacPlugin): void;
 export declare function registerPlugins(pluginList: readonly QvacPlugin[]): void;
 export declare function getPlugin(modelType: string): QvacPlugin | undefined;

package/dist/server/plugins/registry.js

@@ -2,8 +2,15 @@ import { pluginDefinitionRuntimeSchema } from '../../schemas/plugin.js';
 import { isModelTypeAlias } from '../../schemas/index.js';
 import { PluginAlreadyRegisteredError, PluginDefinitionInvalidError, PluginLoggingInvalidError, PluginModelTypeReservedError } from '../../utils/errors-server.js';
 import { createAddonLoggerCallback } from '../../logging/addon.js';
+import { getServerLogger } from '../../logging/index.js';
 import { formatZodError } from '../../utils/zod-error.js';
 const plugins = new Map();
+function getLoggingModule(plugin) {
+    return plugin.logging?.module;
+}
+function findPluginUsingLoggingModule(loggingModule) {
+    return Array.from(plugins.values()).find((plugin) => plugin.logging?.module === loggingModule);
+}
 function getModelTypeForError(plugin) {
     if (!plugin || typeof plugin !== 'object')
         return '(unknown)';
@@ -33,9 +40,16 @@ export function registerPlugin(plugin) {
             throw new PluginLoggingInvalidError(plugin.modelType, 'logging.module must have a setLogger(callback) function');
         }
     }
+    const loggingModule = getLoggingModule(plugin);
+    const pluginUsingLoggingModule = loggingModule
+        ? findPluginUsingLoggingModule(loggingModule)
+        : undefined;
+    if (pluginUsingLoggingModule &&
+        pluginUsingLoggingModule.logging?.namespace !== plugin.logging?.namespace) {
+        throw new PluginLoggingInvalidError(plugin.modelType, 'plugins sharing logging.module must use the same namespace');
+    }
     plugins.set(plugin.modelType, plugin);
-    if (plugin.logging?.module && plugin.logging?.namespace) {
-        const loggingModule = plugin.logging.module;
+    if (loggingModule && plugin.logging?.namespace && !pluginUsingLoggingModule) {
         loggingModule.setLogger(createAddonLoggerCallback(plugin.logging.namespace));
     }
 }
@@ -60,21 +74,34 @@ export function unregisterPlugin(modelType) {
     const plugin = plugins.get(modelType);
     if (!plugin)
         return false;
-    if (plugin.logging?.module) {
-        const loggingModule = plugin.logging.module;
+    const loggingModule = getLoggingModule(plugin);
+    plugins.delete(modelType);
+    if (loggingModule && !findPluginUsingLoggingModule(loggingModule)) {
         loggingModule.releaseLogger?.();
     }
-    return plugins.delete(modelType);
+    return true;
 }
 export function getAllPlugins() {
     return Array.from(plugins.values());
 }
 export function clearPlugins() {
+    const loggingModules = new Map();
     for (const plugin of plugins.values()) {
-        if (plugin.logging?.module) {
-            const loggingModule = plugin.logging.module;
-            loggingModule.releaseLogger?.();
+        const loggingModule = getLoggingModule(plugin);
+        if (loggingModule && !loggingModules.has(loggingModule)) {
+            loggingModules.set(loggingModule, plugin.modelType);
         }
     }
     plugins.clear();
+    for (const [loggingModule, modelType] of loggingModules) {
+        try {
+            loggingModule.releaseLogger?.();
+        }
+        catch (error) {
+            // A plugin's logger teardown must not abort the sweep or leave the
+            // registry half-cleared for the next caller — but surface it, so a leaked
+            // reference or async handle is not masked as a clean teardown.
+            getServerLogger().warn(`[${modelType}] releaseLogger failed during clearPlugins: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
 }

package/dist/server/rpc/create-server.js

@@ -7,9 +7,31 @@ export function createBareKitRPCServer() {
     const { IPC } = globalThis.BareKit;
     return new RPC(IPC, handleRequest);
 }
+/**
+ * Dial the client's IPC endpoint. Two encodings cross the handshake:
+ *
+ * - `tcp://host:port` — a loopback TCP endpoint. Used by clients whose
+ *   runtime has no portable server for filesystem sockets, notably the
+ *   Python `asyncio` transport (`start_unix_server` is Unix-only, and
+ *   asyncio has no cross-platform named-pipe server). One code path on
+ *   every OS, so Windows dials the same way Linux/macOS do.
+ * - anything else — a filesystem path: a Unix domain socket, or a
+ *   `\\.\pipe\...` named pipe on Windows, as the Node client (`node:net`)
+ *   creates.
+ */
+function connectToEndpoint(endpoint) {
+    if (endpoint.startsWith('tcp://')) {
+        const hostPort = endpoint.slice('tcp://'.length);
+        const sep = hostPort.lastIndexOf(':');
+        const host = hostPort.slice(0, sep);
+        const port = Number(hostPort.slice(sep + 1));
+        return connect(port, host);
+    }
+    return connect(endpoint);
+}
 export function createIPCClient(socketPath, options) {
     logger.info(`Connecting to IPC socket at ${socketPath}`);
-    const socket = connect(socketPath);
+    const socket = connectToEndpoint(socketPath);
     socket.on('connect', () => {
         logger.info('Connected to IPC server');
     });

package/dist/server/rpc/delegate-transport.d.ts

@@ -5,8 +5,8 @@
  * delegation to remote peers (via HyperSwarm RPC).
  */
 import type RPC from 'bare-rpc';
-import { DELEGATION_BREAKDOWN_KEY, OPERATION_EVENT_KEY, type Request, type Response, type RPCOptions, type DelegationBreakdown, type OperationEvent } from '../../schemas/index';
-import type { DelegatedHandlerOptions } from './profiling/index';
+import { DELEGATION_BREAKDOWN_KEY, OPERATION_EVENT_KEY, type Request, type Response, type RPCOptions, type DelegationBreakdown, type OperationEvent } from '../../schemas/index.js';
+import type { DelegatedHandlerOptions } from './profiling/index.js';
 export interface DelegateOptions extends RPCOptions, DelegatedHandlerOptions {
     peerKey?: string;
 }

package/dist/server/rpc/delegate-transport.js

@@ -5,14 +5,14 @@
  * delegation to remote peers (via HyperSwarm RPC).
  */
 import { requestSchema, responseSchema, PROFILING_KEY, PROFILING_TRAILER_KEY, DELEGATION_BREAKDOWN_KEY, OPERATION_EVENT_KEY } from '../../schemas/index.js';
-import { nowMs, extractProfilingMeta, stripProfilingMeta, recordFailure, generateId } from '../../profiling/index.js';
+import { nowMs, extractProfilingMeta, stripProfilingMeta, recordFailure, generateId, createDelegatedProfilingMeta } from '../../profiling/index.js';
 import { withTimeout, withTimeoutStream } from '../../utils/withTimeout.js';
 import { getServerLogger } from '../../logging/index.js';
 import { DelegateProviderError } from '../../utils/errors-server.js';
-import { cleanupStaleConnection } from '../bare/delegate-rpc-client.js';
+import { cleanupStaleConnection } from '../../server/bare/delegate-rpc-client.js';
 import { shouldProfileDelegation, createDelegationTimings, createDelegationStreamTimings, recordDelegationEvents, recordDelegationStreamEvents, buildDelegationStreamBreakdown, flushServerConnectionEvent, consumeBreakdownConnectionTime } from './profiling/delegation-profiler.js';
 const logger = getServerLogger();
-import { getNextCommandId } from './rpc-utils.js';
+import { getNextCommandId } from '../../server/rpc/rpc-utils.js';
 function checkAndThrowError(response) {
     if (response.type === 'error') {
         throw new DelegateProviderError(response.message || 'Unknown provider error', response.code);
@@ -61,7 +61,6 @@ async function sendBase(request, rpc, options, profilingMeta) {
 }
 async function sendProfiled(request, rpc, options, profilingMeta) {
     const profileId = profilingMeta?.id ?? generateId();
-    const includeServerBreakdown = profilingMeta?.includeServer ?? false;
     const timings = createDelegationTimings(profileId, request.type);
     try {
         if (options?.peerKey) {
@@ -76,13 +75,9 @@ async function sendProfiled(request, rpc, options, profilingMeta) {
             type: request.type
         });
         const stringifyStart = nowMs();
-        const profilingEnvelope = { id: profileId };
-        if (includeServerBreakdown) {
-            profilingEnvelope['includeServer'] = true;
-        }
         const requestWithProfiling = {
             ...parsedRequest,
-            [PROFILING_KEY]: profilingEnvelope
+            [PROFILING_KEY]: createDelegatedProfilingMeta(profileId, profilingMeta)
         };
         const payload = JSON.stringify(requestWithProfiling);
         timings.requestStringifyMs = nowMs() - stringifyStart;
@@ -183,7 +178,7 @@ async function* streamProfiled(request, rpc, options = {}, profilingMeta) {
         const stringifyStart = nowMs();
         const requestWithProfiling = {
             ...parsedRequest,
-            [PROFILING_KEY]: { id: profileId }
+            [PROFILING_KEY]: createDelegatedProfilingMeta(profileId, profilingMeta)
         };
         const payload = JSON.stringify(requestWithProfiling);
         timings.requestStringifyMs = nowMs() - stringifyStart;

package/dist/server/rpc/handle-request.js

@@ -1,12 +1,12 @@
 import { requestSchema, normalizeModelType, PROFILING_KEY } from '../../schemas/index.js';
 import { nowMs } from '../../profiling/index.js';
-import { resolveModelConfig } from '../bare/registry/model-config-registry.js';
-import { sendErrorResponse, sendStreamErrorResponse } from '../error-handlers.js';
+import { resolveModelConfig } from '../../server/bare/registry/model-config-registry.js';
+import { sendErrorResponse, sendStreamErrorResponse } from '../../server/error-handlers.js';
 import { RPCUnknownRequestTypeError, PluginHandlerTypeMismatchError } from '../../utils/errors-server.js';
 import { registry } from './handler-registry.js';
 import { executeHandler, executeDuplexHandler, handleInitConfig, isInitConfigMessage, handleShutdown, isShutdownMessage } from './handler-utils.js';
 import { createServerProfiler } from './profiling/index.js';
-import { assertLifecycleAllowed } from '../bare/runtime-lifecycle.js';
+import { assertLifecycleAllowed } from '../../server/bare/runtime-lifecycle.js';
 import { shouldUseStreamErrorTransport } from './transport-selector.js';
 export async function handleRequest(req) {
     let profiler;

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

@@ -1,3 +1,3 @@
-import type { HandlerEntry } from './handler-utils';
+import type { HandlerEntry } from './handler-utils.js';
 export declare const registry: Record<string, HandlerEntry>;
 //# sourceMappingURL=handler-registry.d.ts.map

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

@@ -1,43 +1,46 @@
 import {} from '../../schemas/index.js';
-import { handleBatchCompletionStream } from './handlers/batch-completion-stream.js';
-import { handleCompletionStream } from './handlers/completion-stream.js';
-import { handleDownloadAsset } from './handlers/download-asset.js';
-import { handleLoadModel } from './handlers/load-model/index.js';
-import { handleLoadModelDelegated } from './handlers/load-model-delegated.js';
-import { handleCompletionStreamDelegated } from './handlers/completion-stream-delegated.js';
-import { getModelEntry } from '../bare/registry/model-registry.js';
-import { handleUnloadModel } from './handlers/unload-model.js';
-import { handleUnloadModelDelegated } from './handlers/unload-model-delegated.js';
-import { handleTranscribe } from './handlers/transcribe.js';
-import { handleTranscribeStream } from './handlers/transcribe-stream.js';
-import { handleBciTranscribe } from './handlers/bci-transcribe.js';
-import { handleBciTranscribeStream } from './handlers/bci-transcribe-stream.js';
-import { handleEmbed } from './handlers/embed.js';
-import { handleTranslate } from './handlers/translate.js';
-import { handleLoggingStream } from './handlers/logging-stream.js';
+import { handleBatchCompletionStream } from '../../server/rpc/handlers/batch-completion-stream.js';
+import { handleCompletionOrchestrate } from '../../server/rpc/handlers/completion-orchestrate.js';
+import { handleCompletionStream } from '../../server/rpc/handlers/completion-stream.js';
+import { handleDownloadAsset } from '../../server/rpc/handlers/download-asset.js';
+import { handleLoadModel } from '../../server/rpc/handlers/load-model/index.js';
+import { handleLoadModelDelegated } from '../../server/rpc/handlers/load-model-delegated.js';
+import { handleCompletionStreamDelegated } from '../../server/rpc/handlers/completion-stream-delegated.js';
+import { getModelEntry } from '../../server/bare/registry/model-registry.js';
+import { handleUnloadModel } from '../../server/rpc/handlers/unload-model.js';
+import { handleUnloadModelDelegated } from '../../server/rpc/handlers/unload-model-delegated.js';
+import { handleTranscribe } from '../../server/rpc/handlers/transcribe.js';
+import { handleTranscribeStream } from '../../server/rpc/handlers/transcribe-stream.js';
+import { handleBciTranscribe } from '../../server/rpc/handlers/bci-transcribe.js';
+import { handleBciTranscribeStream } from '../../server/rpc/handlers/bci-transcribe-stream.js';
+import { handleEmbed } from '../../server/rpc/handlers/embed.js';
+import { handleTranslate } from '../../server/rpc/handlers/translate.js';
+import { handleLoggingStream } from '../../server/rpc/handlers/logging-stream.js';
 import { cancelHandler } from './handlers/cancelHandler.js';
 import { provideHandler } from './handlers/provideHandler.js';
 import { stopProvideHandler } from './handlers/stopProvideHandler.js';
-import { handleRag } from './handlers/rag.js';
-import { handleDeleteCache } from './handlers/delete-cache.js';
-import { handleTextToSpeech } from './handlers/text-to-speech.js';
-import { handleTextToSpeechStream } from './handlers/text-to-speech-stream.js';
-import { handleGetModelInfo } from './handlers/get-model-info.js';
-import { handleGetLoadedModelInfo } from './handlers/get-loaded-model-info.js';
-import { handleOCRStream } from './handlers/ocr-stream.js';
-import { handleHeartbeat } from './handlers/heartbeat.js';
-import { handleFinetune } from './handlers/finetune.js';
-import { handleHeartbeatDelegated } from './handlers/heartbeat-delegated.js';
-import { handleCancelDelegated } from './handlers/cancel-delegated.js';
-import { handleDiffusionStream } from './handlers/diffusion-stream.js';
-import { handleVideoStream } from './handlers/video-stream.js';
-import { handleUpscaleStream } from './handlers/upscale-stream.js';
-import { handleClassify } from './handlers/classify.js';
-import { handlePluginInvoke, handlePluginInvokeStream } from './handlers/plugin-invoke.js';
-import { handleModelRegistryList, handleModelRegistrySearch, handleModelRegistryGetModel } from './handlers/registry.js';
-import { handleSuspend } from './handlers/suspend.js';
-import { handleResume } from './handlers/resume.js';
-import { handleState } from './handlers/state.js';
+import { handleRag } from '../../server/rpc/handlers/rag.js';
+import { handleDeleteCache } from '../../server/rpc/handlers/delete-cache.js';
+import { handleTextToSpeech } from '../../server/rpc/handlers/text-to-speech.js';
+import { handleTextToSpeechStream } from '../../server/rpc/handlers/text-to-speech-stream.js';
+import { handleGetModelInfo } from '../../server/rpc/handlers/get-model-info.js';
+import { handleGetLoadedModelInfo } from '../../server/rpc/handlers/get-loaded-model-info.js';
+import { handleGetSystemResources } from '../../server/rpc/handlers/get-system-resources.js';
+import { handleOCRStream } from '../../server/rpc/handlers/ocr-stream.js';
+import { handleHeartbeat } from '../../server/rpc/handlers/heartbeat.js';
+import { handleFinetune } from '../../server/rpc/handlers/finetune.js';
+import { handleHeartbeatDelegated } from '../../server/rpc/handlers/heartbeat-delegated.js';
+import { handleCancelDelegated } from '../../server/rpc/handlers/cancel-delegated.js';
+import { handleDiffusionStream } from '../../server/rpc/handlers/diffusion-stream.js';
+import { handleVideoStream } from '../../server/rpc/handlers/video-stream.js';
+import { handleUpscaleStream } from '../../server/rpc/handlers/upscale-stream.js';
+import { handleClassify } from '../../server/rpc/handlers/classify.js';
+import { handleAudioGenStream } from '../../server/rpc/handlers/audio-gen-stream.js';
+import { handlePluginInvoke, handlePluginInvokeStream } from '../../server/rpc/handlers/plugin-invoke.js';
+import { handleModelRegistryList, handleModelRegistrySearch, handleModelRegistryGetModel } from '../../server/rpc/handlers/registry.js';
+import { handleSuspend } from '../../server/rpc/handlers/suspend.js';
+import { handleResume } from '../../server/rpc/handlers/resume.js';
+import { handleState } from '../../server/rpc/handlers/state.js';
 function ragSupportsProgress(request) {
     if (request.type !== 'rag')
         return false;
@@ -108,6 +111,7 @@ export const registry = {
     deleteCache: { type: 'reply', handler: handleDeleteCache },
     getModelInfo: { type: 'reply', handler: handleGetModelInfo },
     getLoadedModelInfo: { type: 'reply', handler: handleGetLoadedModelInfo },
+    getSystemResources: { type: 'reply', handler: handleGetSystemResources },
     pluginInvoke: { type: 'reply', handler: handlePluginInvoke },
     modelRegistryList: { type: 'reply', handler: handleModelRegistryList },
     modelRegistrySearch: { type: 'reply', handler: handleModelRegistrySearch },
@@ -119,6 +123,7 @@ export const registry = {
     resume: { type: 'reply', handler: handleResume },
     state: { type: 'reply', handler: handleState },
     // Simple Stream handlers
+    audioGenStream: { type: 'stream', handler: handleAudioGenStream },
     transcribe: { type: 'stream', handler: handleTranscribe },
     transcribeStream: { type: 'duplex', handler: handleTranscribeStream },
     bciTranscribe: { type: 'stream', handler: handleBciTranscribe },
@@ -147,6 +152,10 @@ export const registry = {
         delegatedHandler: handleCompletionStreamDelegated,
         isDelegated: isModelDelegated
     },
+    // Deliberately no delegated handler: tool callbacks execute code on the
+    // client machine, so only the user's own local worker may orchestrate
+    // (see completionOrchestrateResponseSchema's contract note).
+    completionOrchestrate: { type: 'duplex', handler: handleCompletionOrchestrate },
     batchCompletionStream: {
         type: 'stream',
         handler: handleBatchCompletionStream

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

@@ -1,5 +1,5 @@
-import type { Request } from '../../schemas/index';
-import type { HandlerEntry } from './handler-utils';
+import type { Request } from '../../schemas/index.js';
+import type { HandlerEntry } from '../../server/rpc/handler-utils.js';
 export interface HandlerSelection {
     handler: HandlerEntry['handler'];
     isDelegated: boolean;

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

@@ -1,6 +1,6 @@
-import { type QvacConfig, type Request, type Response, type RuntimeContext } from '../../schemas/index';
+import { type QvacConfig, type Request, type Response, type RuntimeContext } from '../../schemas/index.js';
 import type RPC from 'bare-rpc';
-import { type ServerProfiler } from './profiling/index';
+import { type ServerProfiler } from './profiling/index.js';
 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>;

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 { sendErrorResponse, sendStreamErrorResponse } from '../../server/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 { setSDKConfig } from '../../server/bare/registry/config-registry.js';
+import { setRuntimeContext } from '../../server/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 { handlerSupportsProgress, selectHandler } from '../../server/rpc/handler-selection.js';
 function getProfilingMetaFromRequest(request) {
     if (PROFILING_KEY in request) {
         return request[PROFILING_KEY];
@@ -170,7 +170,7 @@ export async function handleShutdown(req) {
         // 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('../../server/worker-core.js');
         await cleanupForTerminate();
         req.reply(JSON.stringify({ success: true }), 'utf-8');
     }

package/dist/server/rpc/handlers/audio-gen-stream.d.ts

@@ -0,0 +1,3 @@
+import type { AudioGenStreamRequest, AudioGenStreamResponse } from '../../../schemas/audio-gen.js';
+export declare function handleAudioGenStream(request: AudioGenStreamRequest): AsyncGenerator<AudioGenStreamResponse>;
+//# sourceMappingURL=audio-gen-stream.d.ts.map

package/dist/server/rpc/handlers/audio-gen-stream.js

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

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

@@ -1,4 +1,4 @@
-import type { BatchCompletionStreamRequest } from '../../../schemas/index';
+import type { BatchCompletionStreamRequest } from '../../../schemas/index.js';
 export declare function handleBatchCompletionStream(request: BatchCompletionStreamRequest): AsyncGenerator<{
     type: "batchCompletionStream";
     events: {
@@ -41,6 +41,7 @@ export declare function handleBatchCompletionStream(request: BatchCompletionStre
                 cacheTokens?: number | undefined;
                 promptTokens?: number | undefined;
                 generatedTokens?: number | undefined;
+                emittedTokens?: number | undefined;
                 avgConcurrentSeq?: number | undefined;
                 backendDevice?: "gpu" | "cpu" | undefined;
             };
@@ -71,6 +72,7 @@ export declare function handleBatchCompletionStream(request: BatchCompletionStre
         cacheTokens?: number | undefined;
         promptTokens?: number | undefined;
         generatedTokens?: number | undefined;
+        emittedTokens?: number | undefined;
         avgConcurrentSeq?: number | undefined;
         backendDevice?: "gpu" | "cpu" | undefined;
     } | undefined;

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

@@ -1,4 +1,4 @@
-import { dispatchPluginStream } from './plugin-dispatch.js';
+import { dispatchPluginStream } from '../../../server/rpc/handlers/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.js';
 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 '../../../server/rpc/handlers/plugin-dispatch.js';
 export async function* handleBciTranscribeStream(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.js';
 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 '../../../server/rpc/handlers/plugin-dispatch.js';
 export async function* handleBciTranscribe(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.js';
+import type { DelegatedHandlerOptions } from '../../../server/rpc/profiling/index.js';
 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 { getModelEntry } from '../../../server/bare/registry/model-registry.js';
+import { getRPC } from '../../../server/bare/delegate-rpc-client.js';
+import { send } from '../../../server/rpc/delegate-transport.js';
 const logger = getServerLogger();
 /**
  * Resolve the delegated provider for a cancel request, if any.

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.js';
 /**
  * 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,6 +1,6 @@
-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 { cancel as cancelByModelId } from '../../../server/bare/ops/cancel.js';
+import { getRequestRegistry } from '../../../server/bare/runtime/index.js';
+import { markClearCacheForRequest } from '../../../server/rpc/handlers/load-model/download-manager.js';
 import { getServerLogger } from '../../../logging/index.js';
 const logger = getServerLogger();
 /**

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.js';
 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 '../../../server/rpc/handlers/plugin-dispatch.js';
 export async function* handleClassify(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.js';
+import { type ToolCallbackResult } from '../../../schemas/completion-stream.js';
+/**
+ * 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