@qvac/sdk 0.18.2 → 0.19.0

package/dist/src/index.d.ts

@@ -0,0 +1,20 @@
+export { batchCompletion, completion, deleteCache, loadModel, downloadAsset, heartbeat, unloadModel, transcribe, transcribeStream, bciTranscribe, bciTranscribeStream, embed, finetune, translate, cancel, ragChunk, ragIngest, ragSaveEmbeddings, ragSearch, ragDeleteEmbeddings, ragReindex, ragListWorkspaces, ragCloseWorkspace, ragDeleteWorkspace, textToSpeech, textToSpeechStream, getModelInfo, getLoadedModelInfo, getSystemResources, assessModelFit, loggingStream, subscribeServerLogs, type ServerLogHandler, ocr, invokePlugin, invokePluginStream, diffusion, type DiffusionProgressTick, classify, video, type VideoProgressTick, upscale, worldCreateScene, worldStep, type WorldStepResult, type WorldStepProgressTick, type WorldSceneResult, type WorldSceneResultWithPack, modelRegistryList, modelRegistrySearch, modelRegistryGetModel, type ModelRegistrySearchParams, suspend, resume, state, vla, vlaHparams, vlaSetEmbodiment, vlaPreprocessImage, vlaPadState, VLA_DEFAULT_IMAGE_SIZE, audioGen, type FinetuneHandle } from './client/api/index.js';
+export { close } from './client/index.js';
+export { plugins } from './client/plugins-factory.js';
+export { type LifecycleState, type ModelProgressUpdate, type LoadModelOptions, type LoadCustomPluginModelOptions, type DownloadAssetOptions, type Tool, type ToolCall, type ToolCallWithCall, type ToolCallError, type ToolCallEvent, type CompletionEvent, type CompletionFinal, type CompletionRun, type CompletionStats, type BatchCompletionEvent, type BatchCompletionResult, type BatchCompletionRun, type BatchPrompt, type EmbedStats, type TranscribeStats, VERBOSITY, type Attachment, type TranscribeStreamSession, type TranscribeStreamMetadataSession, type TranscribeStreamConversationSession, type TranscribeStreamEvent, type VadStateEvent, type EndOfTurnEvent, type TranscribeSegment, type BciConfig, type BciTranscribeClientParams, type BciTranscribeStreamClientParams, type BciTranscribeStreamSession, type BciTranscribeStreamMetadataSession, type BciStreamOpts, type NeuralInput, type TextToSpeechStreamSession, type TextToSpeechStreamResponse, type TextToSpeechStreamClientParams, type TtsClientParamsInput, type TtsParlerEmotion, type TtsParlerLoadConfig, type TtsParlerRuntimeConfig, TTS_PACES, TTS_COSYVOICE3_EMOTIONS, TTS_COSYVOICE3_INSTRUCT_DIALECTS, TTS_COSYVOICE3_INSTRUCT_VOLUMES, TTS_COSYVOICE3_INSTRUCT_STYLES, type TtsPace, type TtsCosyvoice3Emotion, type TtsCosyvoice3Instruct, type TtsCosyvoice3LoadConfig, type TtsCosyvoice3RuntimeConfig, type TtsAudio8LoadConfig, type TtsAudio8RuntimeConfig, type CompletionParams, type ToolDialect, type RagSearchResult, type RagSaveEmbeddingsResult, type RagReindexResult, type RagEmbeddedDoc, type RagDoc, type RagWorkspaceInfo, type RagCloseWorkspaceParams, type RagDeleteWorkspaceParams, type RagIngestStage, type RagReindexStage, type RagSaveStage, RAG_ERROR_CODES, type QvacConfig, type ModelInfo, type GetModelInfoParams, type GetLoadedModelInfoParams, type LoadedModelInfo, type GetSystemResourcesInput, type ResourceScope, type ResourceProvenance, type ResourceMetric, type GraphicsDriver, type GraphicsDriverCapabilities, type BackendProbeResult, type BackendDevice, type BackendDriver, type BackendFallback, type InferenceBackendDiagnostics, type CPUResourceCapabilities, type GPUResourceCapabilities, type SystemResourceCapabilities, type GPUResourceSample, type SystemResourceSample, type SystemResources, type AssessModelFitInput, type AssessModelFitResult, type LoadedInstance, type CacheFileInfo, toolSchema, type McpClient, type McpClientInput, type OCRClientParams, type OCRTextBlock, type OCROptions, type ClassifyClientParams, type ClassificationResult, type DiffusionClientParams, type DiffusionStreamResponse, type DiffusionStats, AUDIOGEN_ENGINES, AUDIOGEN_TASK_TYPES, AUDIOGEN_INPUT_SAMPLE_RATE, AUDIOGEN_INPUT_CHANNELS, AUDIOGEN_INPUT_MAX_SECONDS, type AudioGenEngine, type AudioGenTaskType, type AudioGenAudioInput, type AudioGenClientParams, type AudioGenConfig, type AudioGenRuntimeConfig, type AudioGenProgress, type AudioGenAudio, type AudioGenStats, type AudioGenResult, type AudioGenStreamResponse, type VideoClientParams, type VideoStreamResponse, type VideoStats, type UpscaleClientParams, type UpscaleStreamResponse, type UpscaleStats, type WalkKey, type WalkKeysInput, type WorldStepClientParams, type WorldStepStreamResponse, type WorldStepStats, type WorldSceneClientParams, type WorldSceneStreamResponse, type WorldSceneStats, type VlaConfig, type VlaClientRunParams, type VlaClientRunResult, type VlaEmbodimentSelection, type VlaEmbodimentSelector, type VlaHparams, type VlaStats, definePlugin, defineHandler, defineDuplexHandler, PluginDefinitionInvalidError, type QvacPlugin, type CreateModelParams, type PluginModelResult, type ModelRegistryEntry, type ModelRegistryEntryAddon, type ProfilerMode, type FinetuneValidation, type FinetuneRunParams, type FinetuneGetStateParams, type FinetuneStopParams, type FinetuneParams, type FinetuneStatus, type FinetuneProgress, type FinetuneStats, type FinetuneResult } from '@qvac/inference/surface';
+export { SDK_CLIENT_ERROR_CODES } from './schemas/sdk-errors-client.js';
+export { SDK_SERVER_ERROR_CODES } from './schemas/sdk-errors-server.js';
+export { PLUGIN_LLM, PLUGIN_EMBEDDING, PLUGIN_WHISPER, PLUGIN_BCI, PLUGIN_NMT, PLUGIN_TTS, PLUGIN_OCR, PLUGIN_DIFFUSION, PLUGIN_AUDIOGEN, PLUGIN_VLA, PLUGIN_CLASSIFICATION, SDK_DEFAULT_PLUGINS, type BuiltinPlugin } from './plugin-ids.js';
+export { type ToolInput, type ToolHandler } from './utils/tool-helpers.js';
+export { MODEL_TYPES, ModelType } from '@qvac/inference/surface';
+export * from '@qvac/inference/models';
+export { SUPPORTED_AUDIO_FORMATS } from '@qvac/inference/surface';
+export { InferenceCancelledError } from './utils/errors-server.js';
+export type { InferenceCancelledPartial } from './utils/errors-server.js';
+export { ContextOverflowError, type ContextOverflowErrorSizes, RequestIdConflictError, RequestNotFoundError, RequestRejectedByPolicyError, TranslationFailedError } from './utils/errors-server.js';
+export { BareRuntimeBinaryNotFoundError, WorkerCrashedError, WorkerShutdownError, WorkerStartupError, RequestValidationFailedError, StreamEndedError } from './utils/errors-client.js';
+export { getLogger, SDK_LOG_ID, SDK_ALL_LOG_ID } from './logging/index.js';
+export type { Logger, LogTransport, LoggerOptions } from './logging/index.js';
+export { profiler, attachBackendDiagnostics } from '@qvac/inference/surface';
+export type { ProfilerRuntimeOptions, ProfilerExport, ProfilingEvent, ProfilerGPUResourceGauge, ProfilerResourceGauge } from '@qvac/inference/surface';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/index.js

@@ -0,0 +1,59 @@
+// Public API exports only
+export { batchCompletion, completion, deleteCache, loadModel, downloadAsset, heartbeat, unloadModel, transcribe, transcribeStream, bciTranscribe, bciTranscribeStream, embed, finetune, translate, cancel, ragChunk, ragIngest, ragSaveEmbeddings, ragSearch, ragDeleteEmbeddings, ragReindex, ragListWorkspaces, ragCloseWorkspace, ragDeleteWorkspace, textToSpeech, textToSpeechStream, getModelInfo, getLoadedModelInfo, getSystemResources, assessModelFit, loggingStream, subscribeServerLogs, ocr, invokePlugin, invokePluginStream, diffusion, classify, video, upscale, worldCreateScene, worldStep, modelRegistryList, modelRegistrySearch, modelRegistryGetModel, suspend, resume, state, vla, vlaHparams, vlaSetEmbodiment, vlaPreprocessImage, vlaPadState, VLA_DEFAULT_IMAGE_SIZE, audioGen } from './client/api/index.js';
+export { close } from './client/index.js';
+export { plugins } from './client/plugins-factory.js';
+export { VERBOSITY, TTS_PACES, TTS_COSYVOICE3_EMOTIONS, TTS_COSYVOICE3_INSTRUCT_DIALECTS, TTS_COSYVOICE3_INSTRUCT_VOLUMES, TTS_COSYVOICE3_INSTRUCT_STYLES, RAG_ERROR_CODES, toolSchema, AUDIOGEN_ENGINES, AUDIOGEN_TASK_TYPES, AUDIOGEN_INPUT_SAMPLE_RATE, AUDIOGEN_INPUT_CHANNELS, AUDIOGEN_INPUT_MAX_SECONDS, definePlugin, defineHandler, defineDuplexHandler, PluginDefinitionInvalidError } from '@qvac/inference/surface';
+// SDK-owned error-code objects: `SDK_CLIENT_ERROR_CODES` holds transport/client
+// codes absent from @qvac/inference, and `SDK_SERVER_ERROR_CODES` carries the
+// client-side error definitions (`addCodes` message registry) that
+// @qvac/inference's value-clean surface does not provide.
+export { SDK_CLIENT_ERROR_CODES } from './schemas/sdk-errors-client.js';
+export { SDK_SERVER_ERROR_CODES } from './schemas/sdk-errors-server.js';
+// Built-in plugin ids under the public @qvac/sdk name (see `@/plugin-ids`).
+export { PLUGIN_LLM, PLUGIN_EMBEDDING, PLUGIN_WHISPER, PLUGIN_BCI, PLUGIN_NMT, PLUGIN_TTS, PLUGIN_OCR, PLUGIN_DIFFUSION, PLUGIN_AUDIOGEN, PLUGIN_VLA, PLUGIN_CLASSIFICATION, SDK_DEFAULT_PLUGINS } from './plugin-ids.js';
+export {} from './utils/tool-helpers.js';
+// Model types - canonical naming with backward-compatible aliases
+export { MODEL_TYPES, ModelType } from '@qvac/inference/surface';
+// Model registry constants
+export * from '@qvac/inference/models';
+export { SUPPORTED_AUDIO_FORMATS } from '@qvac/inference/surface';
+// Error classes that clients need for `instanceof` checks on rejected
+// promises. `InferenceCancelledError` rides the standard `QvacError`
+// envelope, but consumers reach for it through `instanceof` on
+// `await run.final` / `run.text` / `run.toolCalls` / `run.stats`
+// rejections. `RequestRejectedByPolicyError` is thrown by
+// `await RequestRegistry.begin(...)` when a registered concurrency policy
+// refuses a new request. A same-model `completion` doesn't reject — it waits
+// FIFO — so this surfaces only when the per-model wait queue is already at its
+// `maxQueueDepthPerModel` cap. It propagates out through the worker so the
+// client can distinguish "the model is saturated" from "the request failed".
+//
+// `RequestIdConflictError` and `RequestNotFoundError` are thrown by
+// `await RequestRegistry.begin(...)` / `.end(...)` on UUID collisions and
+// missing-target cancels. They're surfaced here so consumers using
+// the decorated-promise `requestId` can pattern-match on rejected
+// cancel paths. All three classes round-trip the RPC boundary via
+// the typed-error reconstructor in `client/rpc/rpc-error.ts` so
+// `err instanceof <Class>` works on the consumer side, not just on
+// the worker side.
+export { InferenceCancelledError } from './utils/errors-server.js';
+export { ContextOverflowError, RequestIdConflictError, RequestNotFoundError, RequestRejectedByPolicyError, TranslationFailedError } from './utils/errors-server.js';
+// `WorkerCrashedError` and `WorkerShutdownError` are thrown by the
+// rpc-client life-signal race when the bare worker exits unexpectedly
+// or close()/process-exit teardown runs while a caller is in flight.
+// `WorkerStartupError` is the pre-handshake counterpart: it is never thrown
+// directly, it is the `cause` of `RPCInitTimeoutError`, and it carries
+// `workerExited` / `exitCode` / `exitSignal` / `stderrTail` so a host can tell a
+// crashed worker from a slow one without parsing the message.
+// `BareRuntimeBinaryNotFoundError` is thrown when the worker fails to
+// spawn because the platform's `bare-runtime-<platform>-<arch>` package is
+// missing (common under pnpm). Exported so consumers can pattern-match with
+// `instanceof`.
+// `StreamEndedError` is raised by the streaming result helpers (upscale, world)
+// when the RPC stream closes without a terminal `done` frame. Exported for the
+// same reason as the rest of this block: matching on it requires the class.
+export { BareRuntimeBinaryNotFoundError, WorkerCrashedError, WorkerShutdownError, WorkerStartupError, RequestValidationFailedError, StreamEndedError } from './utils/errors-client.js';
+// Logging exports
+export { getLogger, SDK_LOG_ID, SDK_ALL_LOG_ID } from './logging/index.js';
+// Profiler exports
+export { profiler, attachBackendDiagnostics } from '@qvac/inference/surface';

package/dist/src/logging/addon.d.ts

@@ -0,0 +1,6 @@
+import type { Logger } from './index.js';
+export declare function registerAddonLogger(modelId: string, namespace: string, logger: Logger): void;
+export declare function unregisterAddonLogger(modelId: string): void;
+export declare function createAddonLoggerCallback(namespace: string): (priority: number, message: string) => void;
+export declare function clearAllAddonLoggers(): void;
+//# sourceMappingURL=addon.d.ts.map

package/dist/src/logging/logging-stream-registry.js

@@ -0,0 +1,137 @@
+/**
+ * Logging Stream Registry
+ *
+ * Manages RPC subscriptions for streaming logs from server to connected clients.
+ *
+ * Purpose:
+ * - Registers client subscriptions to model/SDK log streams
+ * - Routes log messages to subscribed clients via RPC
+ * - Buffers logs during model loading (before client subscribes)
+ * - Manages stream lifecycle (subscribe/unsubscribe)
+ *
+ */
+import { SDK_ALL_LOG_ID } from './namespaces.js';
+const loggingStreams = new Map();
+// Buffering for logs emitted during model loading (before client subscribes)
+const MAX_BUFFERED_LOGS_PER_MODEL = 100;
+const BUFFER_EXPIRY_MS = 30_000;
+const BUFFERING_TIMEOUT_MS = 5_000;
+const logBuffer = new Map();
+const modelsWithBuffering = new Set();
+const bufferingTimeouts = new Map();
+function clearBufferingTimeout(id) {
+    const timeout = bufferingTimeouts.get(id);
+    if (timeout) {
+        clearTimeout(timeout);
+        bufferingTimeouts.delete(id);
+    }
+}
+export function startLogBuffering(id) {
+    modelsWithBuffering.add(id);
+}
+export function stopLogBufferingWithTimeout(id) {
+    clearBufferingTimeout(id);
+    const timeout = setTimeout(() => {
+        if (modelsWithBuffering.has(id)) {
+            modelsWithBuffering.delete(id);
+            logBuffer.delete(id);
+        }
+        bufferingTimeouts.delete(id);
+    }, BUFFERING_TIMEOUT_MS);
+    bufferingTimeouts.set(id, timeout);
+}
+export function registerLoggingStream(id, streamHandler) {
+    if (!loggingStreams.has(id)) {
+        loggingStreams.set(id, new Set());
+    }
+    loggingStreams.get(id).add(streamHandler);
+    const buffered = logBuffer.get(id);
+    if (buffered && buffered.length > 0) {
+        for (const log of buffered) {
+            try {
+                streamHandler(log.level, log.namespace, log.message, log.sourceId);
+            }
+            catch (error) {
+                console.error(`Error flushing buffered log for ID ${id}:`, error); // fallback (avoid recursion)
+            }
+        }
+        logBuffer.delete(id);
+    }
+    modelsWithBuffering.delete(id);
+    clearBufferingTimeout(id);
+}
+export function unregisterLoggingStream(id, streamHandler) {
+    const streams = loggingStreams.get(id);
+    if (streams) {
+        streams.delete(streamHandler);
+        if (streams.size === 0) {
+            loggingStreams.delete(id);
+        }
+    }
+}
+export function unregisterAllLoggingStreams(id) {
+    // Simply remove all logging handlers
+    // Active streams will naturally terminate when no more logs flow
+    loggingStreams.delete(id);
+    logBuffer.delete(id);
+    modelsWithBuffering.delete(id);
+    clearBufferingTimeout(id);
+}
+export function sendLogToStreams(id, level, namespace, message) {
+    // The originating id is preserved as `sourceId` so the global stream keeps the
+    // real origin of each log instead of reporting the subscription id.
+    deliverToStream(id, level, namespace, message, id);
+    if (id !== SDK_ALL_LOG_ID) {
+        deliverToStream(SDK_ALL_LOG_ID, level, namespace, message, id);
+    }
+}
+function deliverToStream(id, level, namespace, message, sourceId) {
+    const streams = loggingStreams.get(id);
+    const isBuffering = modelsWithBuffering.has(id);
+    if (streams && streams.size > 0) {
+        for (const streamHandler of streams) {
+            try {
+                streamHandler(level, namespace, message, sourceId);
+            }
+            catch (error) {
+                console.error(`Error sending log to stream for ID ${id}:`, error); // fallback (avoid recursion)
+            }
+        }
+    }
+    else if (isBuffering) {
+        if (!logBuffer.has(id)) {
+            logBuffer.set(id, []);
+        }
+        const buffer = logBuffer.get(id);
+        const now = Date.now();
+        const validLogs = buffer.filter((log) => now - log.timestamp < BUFFER_EXPIRY_MS);
+        if (validLogs.length >= MAX_BUFFERED_LOGS_PER_MODEL) {
+            validLogs.shift();
+        }
+        validLogs.push({ level, namespace, message, sourceId, timestamp: now });
+        logBuffer.set(id, validLogs);
+    }
+}
+export function hasLoggingStreams(id) {
+    const streams = loggingStreams.get(id);
+    return streams && streams.size > 0;
+}
+export function getLoggingStreamStats() {
+    return {
+        totalIds: loggingStreams.size,
+        ids: Array.from(loggingStreams.keys()),
+        totalStreams: Array.from(loggingStreams.values()).reduce((sum, streams) => sum + streams.size, 0),
+        bufferedIds: logBuffer.size,
+        idsWithBuffering: modelsWithBuffering.size,
+        activeTimeouts: bufferingTimeouts.size
+    };
+}
+export function clearAllLoggingStreams() {
+    for (const timeout of bufferingTimeouts.values()) {
+        clearTimeout(timeout);
+    }
+    loggingStreams.clear();
+    logBuffer.clear();
+    modelsWithBuffering.clear();
+    bufferingTimeouts.clear();
+}

package/dist/src/logging/namespaces.d.ts

@@ -0,0 +1,7 @@
+import { type CanonicalModelType } from '@qvac/inference/surface';
+export declare const RAG_NAMESPACE: "rag:hyperdb";
+export type AddonNamespace = CanonicalModelType | typeof RAG_NAMESPACE;
+export declare const SDK_LOG_ID = "__engine__";
+export declare const SDK_ALL_LOG_ID = "__all__";
+export declare const SDK_SERVER_NAMESPACE = "sdk:server";
+//# sourceMappingURL=namespaces.d.ts.map

package/dist/src/logging/namespaces.js

@@ -0,0 +1,8 @@
+import { LOG_ID, ALL_LOG_ID } from '@qvac/inference/surface';
+export const RAG_NAMESPACE = 'rag:hyperdb';
+// Reserved ID for SDK server logs
+export const SDK_LOG_ID = LOG_ID;
+// Reserved ID for the stream that receives all server-side logs
+export const SDK_ALL_LOG_ID = ALL_LOG_ID;
+// Namespace for all SDK server logs
+export const SDK_SERVER_NAMESPACE = 'sdk:server';

package/dist/src/logging/registry.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Logger Instance Registry (Per-Process)
+ *
+ * Manages the lifecycle of all Logger instances in the CURRENT PROCESS.
+ * Client and server run as separate processes, each with their own registry instance.
+ *
+ * Purpose:
+ * - Tracks all Logger objects in this process (getLogger, createStreamLogger, etc.)
+ * - Enables process-wide log level control via setGlobalLogLevel()
+ * - Enables process-wide console output control via setGlobalConsoleOutput()
+ * - Ensures proper cleanup when loggers are no longer needed
+ *
+ * Config Integration:
+ * - loggerLevel and loggerConsoleOutput from config file apply to both processes
+ * - Client applies settings after loading config, server applies during __init_config
+ *
+ * NOTE: This is separate from logging/logging-stream-registry.ts
+ * which manages RPC subscriptions for streaming logs to connected clients.
+ *
+ * IMPORTANT: Some bundlers may evaluate the same logical module multiple times with
+ * subpath imports like `#rpc`, which can duplicate internal module state.
+ * We use globalThis + Symbol.for() to guarantees a single instance across all
+ * module evaluations and runtimes.
+ */
+import type { LogLevel } from '@qvac/logging';
+import type { Logger } from './types.js';
+export declare function registerLogger(logger: Logger): void;
+export declare function unregisterLogger(logger: Logger): void;
+export declare function setGlobalLogLevel(level: LogLevel): void;
+export declare function setGlobalConsoleOutput(enabled: boolean): void;
+//# sourceMappingURL=registry.d.ts.map

package/dist/src/logging/registry.js

@@ -0,0 +1,62 @@
+/**
+ * Logger Instance Registry (Per-Process)
+ *
+ * Manages the lifecycle of all Logger instances in the CURRENT PROCESS.
+ * Client and server run as separate processes, each with their own registry instance.
+ *
+ * Purpose:
+ * - Tracks all Logger objects in this process (getLogger, createStreamLogger, etc.)
+ * - Enables process-wide log level control via setGlobalLogLevel()
+ * - Enables process-wide console output control via setGlobalConsoleOutput()
+ * - Ensures proper cleanup when loggers are no longer needed
+ *
+ * Config Integration:
+ * - loggerLevel and loggerConsoleOutput from config file apply to both processes
+ * - Client applies settings after loading config, server applies during __init_config
+ *
+ * NOTE: This is separate from logging/logging-stream-registry.ts
+ * which manages RPC subscriptions for streaming logs to connected clients.
+ *
+ * IMPORTANT: Some bundlers may evaluate the same logical module multiple times with
+ * subpath imports like `#rpc`, which can duplicate internal module state.
+ * We use globalThis + Symbol.for() to guarantees a single instance across all
+ * module evaluations and runtimes.
+ */
+const REGISTRY_KEY = Symbol.for('@qvac/sdk:logger-registry');
+const GLOBAL_LEVEL_KEY = Symbol.for('@qvac/sdk:global-log-level');
+const GLOBAL_CONSOLE_KEY = Symbol.for('@qvac/sdk:global-console-output');
+function getGlobal() {
+    return globalThis;
+}
+function getRegistry() {
+    const global = getGlobal();
+    if (!global[REGISTRY_KEY]) {
+        global[REGISTRY_KEY] = new Set();
+    }
+    return global[REGISTRY_KEY];
+}
+export function registerLogger(logger) {
+    const global = getGlobal();
+    getRegistry().add(logger);
+    if (global[GLOBAL_LEVEL_KEY] !== undefined) {
+        logger.setLevel(global[GLOBAL_LEVEL_KEY]);
+    }
+    if (global[GLOBAL_CONSOLE_KEY] !== undefined) {
+        logger.setConsoleOutput(global[GLOBAL_CONSOLE_KEY]);
+    }
+}
+export function unregisterLogger(logger) {
+    getRegistry().delete(logger);
+}
+export function setGlobalLogLevel(level) {
+    getGlobal()[GLOBAL_LEVEL_KEY] = level;
+    for (const logger of getRegistry()) {
+        logger.setLevel(level);
+    }
+}
+export function setGlobalConsoleOutput(enabled) {
+    getGlobal()[GLOBAL_CONSOLE_KEY] = enabled;
+    for (const logger of getRegistry()) {
+        logger.setConsoleOutput(enabled);
+    }
+}

package/dist/src/logging/stream-logger.js

@@ -0,0 +1,12 @@
+import { sendLogToStreams } from './logging-stream-registry.js';
+import { createBaseLogger } from './base-logger.js';
+export function createStreamLogger(id, namespace, options) {
+    return createBaseLogger(namespace, {
+        enableConsole: false, // Default to disable console output for stream loggers
+        ...options
+    }, {
+        onLog: (level, namespace, message) => {
+            sendLogToStreams(id, level, namespace, message);
+        }
+    });
+}

package/dist/src/logging/utils.d.ts

@@ -0,0 +1,6 @@
+import type { LogLevel } from '@qvac/logging';
+import type { Request } from '@qvac/inference/surface';
+export declare function isLevelEnabled(messageLevel: LogLevel, currentLevel: LogLevel): boolean;
+export declare function formatArg(arg: unknown): string;
+export declare function summarizeRequest(request: Request): Record<string, unknown>;
+//# sourceMappingURL=utils.d.ts.map

package/dist/src/models/registry/index.d.ts

@@ -0,0 +1,2 @@
+export * from '@qvac/inference/models';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/models/registry/index.js

@@ -0,0 +1,4 @@
+// Public `@qvac/sdk/models` subpath. The model registry lives in @qvac/inference; the SDK
+// re-exports it under its own subpath so consumers keep importing from
+// `@qvac/sdk/models`.
+export * from '@qvac/inference/models';