@qvac/sdk 0.18.2 → 0.19.0

package/dist/client/api/state.js

@@ -1,29 +0,0 @@
-import { send } from '../../client/rpc/rpc-client.js';
-import { InvalidResponseError } from '../../utils/errors-client.js';
-/**
- * Returns the current runtime lifecycle state.
- *
- * Safe to call from any lifecycle state — `state()` is never blocked by the
- * lifecycle gate (along with `suspend()` and `resume()`).
- *
- * @returns The current lifecycle state:
- *   - `"active"`: all SDK operations are allowed
- *   - `"suspending"` | `"suspended"` | `"resuming"`: non-lifecycle operations
- *     throw `LifecycleOperationBlockedError`
- *
- * @throws {InvalidResponseError} When the response envelope does not match the request type.
- *
- * @example
- * // Branch on lifecycle state before issuing work
- * const current = await state();
- * if (current !== "active") {
- *   await resume();
- * }
- */
-export async function state() {
-    const response = await send({ type: 'state' });
-    if (response.type !== 'state') {
-        throw new InvalidResponseError('state');
-    }
-    return response.state;
-}

package/dist/client/api/stop-provider.d.ts

@@ -1,21 +0,0 @@
-/**
- * Stops the running provider service.
- *
- * After this call returns, incoming peer connections are dropped at the RPC
- * layer and remote `loadModel`/`completion`/etc. requests will no longer be
- * served. The keyPair stays bound on the DHT (a `swarm.listen()` cannot be
- * undone without tearing down the shared swarm), so peers may still open a
- * raw socket — but those sockets are immediately destroyed and no RPC server
- * is mounted on them.
- *
- * Idempotent: calling more than once with no provider running is a no-op.
- *
- * @returns A promise that resolves to the stop provide response containing success status
- * @throws {QvacErrorBase} When the response type is not "stopProvide" or the request fails
- */
-export declare function stopQVACProvider(): Promise<{
-    type: "stopProvide";
-    success: boolean;
-    error?: string | undefined;
-}>;
-//# sourceMappingURL=stop-provider.d.ts.map

package/dist/client/api/stop-provider.js

@@ -1,31 +0,0 @@
-import {} from '../../schemas/index.js';
-import { send } from '../../client/rpc/rpc-client.js';
-import { InvalidResponseError, ProviderStopFailedError } from '../../utils/errors-client.js';
-/**
- * Stops the running provider service.
- *
- * After this call returns, incoming peer connections are dropped at the RPC
- * layer and remote `loadModel`/`completion`/etc. requests will no longer be
- * served. The keyPair stays bound on the DHT (a `swarm.listen()` cannot be
- * undone without tearing down the shared swarm), so peers may still open a
- * raw socket — but those sockets are immediately destroyed and no RPC server
- * is mounted on them.
- *
- * Idempotent: calling more than once with no provider running is a no-op.
- *
- * @returns A promise that resolves to the stop provide response containing success status
- * @throws {QvacErrorBase} When the response type is not "stopProvide" or the request fails
- */
-export async function stopQVACProvider() {
-    const request = {
-        type: 'stopProvide'
-    };
-    const response = await send(request);
-    if (response.type !== 'stopProvide') {
-        throw new InvalidResponseError('stopProvide');
-    }
-    if (response.error) {
-        throw new ProviderStopFailedError(response.error);
-    }
-    return response;
-}

package/dist/client/api/subscribe-logs.d.ts

@@ -1,28 +0,0 @@
-import type { LoggingStreamResponse } from '../../schemas/logging-stream.js';
-export type ServerLogHandler = (log: LoggingStreamResponse) => void;
-/**
- * Subscribes to every server-side log through a single stream: SDK server logs,
- * per-model addon logs (llamacpp, whispercpp, …) for all loaded models, and RAG
- * logs — without having to open a {@link loggingStream} per id.
- *
- * Each delivered log keeps its origin in `log.id`: `SDK_LOG_ID` for SDK server
- * logs, the model id for model logs, or the RAG workspace key. Use it to tell the
- * sources apart.
- *
- * Internally this opens a {@link loggingStream} on the reserved `SDK_ALL_LOG_ID`
- * stream that the worker fans every log into.
- *
- * @param handler - called once per log line.
- * @returns a function that stops the subscription.
- *
- * @example
- * ```typescript
- * const unsubscribe = subscribeServerLogs((log) => {
- *   console.log(`[${log.level}] ${log.id} ${log.namespace}: ${log.message}`);
- * });
- * // later
- * unsubscribe();
- * ```
- */
-export declare function subscribeServerLogs(handler: ServerLogHandler): () => void;
-//# sourceMappingURL=subscribe-logs.d.ts.map

package/dist/client/api/suspend.d.ts

@@ -1,31 +0,0 @@
-/**
- * Suspends the SDK runtime: pauses all registered Hyperswarm and Corestore
- * resources and engages the lifecycle gate so non-lifecycle operations are
- * blocked until `resume()` is called.
- *
- * Safe to call from any lifecycle state — `suspend()` is never blocked by the
- * lifecycle gate (along with `resume()` and `state()`). Idempotent.
- *
- * After `suspend()` resolves, runtime state is `"suspended"` and any non-
- * lifecycle SDK operation throws `LifecycleOperationBlockedError` until
- * `resume()` is called.
- *
- * In-flight operations started before suspend:
- *   - P2P / Hyperdrive downloads: stall cleanly, continue after `resume()`
- *   - HTTP downloads: bypass suspend entirely (bytes keep flowing)
- *   - Local native inference: runs to completion regardless
- *   - Delegated reply RPCs: stall, then auto-recover after `resume()`
- *     (subject to delegate `timeout`)
- *   - Delegated stream RPCs: severed, consumer iterator hangs silently;
- *     re-issue after `resume()` works normally.
- *
- * @throws {RPCError} When one or more resources fail to suspend. The runtime
- *   still commits to `"suspended"` so callers can recover with `resume()`.
- *
- * @example
- * // Background handler
- * await suspend();
- * console.log(await state()); // "suspended"
- */
-export declare function suspend(): Promise<void>;
-//# sourceMappingURL=suspend.d.ts.map

package/dist/client/api/suspend.js

@@ -1,37 +0,0 @@
-import { send } from '../../client/rpc/rpc-client.js';
-import { InvalidResponseError } from '../../utils/errors-client.js';
-/**
- * Suspends the SDK runtime: pauses all registered Hyperswarm and Corestore
- * resources and engages the lifecycle gate so non-lifecycle operations are
- * blocked until `resume()` is called.
- *
- * Safe to call from any lifecycle state — `suspend()` is never blocked by the
- * lifecycle gate (along with `resume()` and `state()`). Idempotent.
- *
- * After `suspend()` resolves, runtime state is `"suspended"` and any non-
- * lifecycle SDK operation throws `LifecycleOperationBlockedError` until
- * `resume()` is called.
- *
- * In-flight operations started before suspend:
- *   - P2P / Hyperdrive downloads: stall cleanly, continue after `resume()`
- *   - HTTP downloads: bypass suspend entirely (bytes keep flowing)
- *   - Local native inference: runs to completion regardless
- *   - Delegated reply RPCs: stall, then auto-recover after `resume()`
- *     (subject to delegate `timeout`)
- *   - Delegated stream RPCs: severed, consumer iterator hangs silently;
- *     re-issue after `resume()` works normally.
- *
- * @throws {RPCError} When one or more resources fail to suspend. The runtime
- *   still commits to `"suspended"` so callers can recover with `resume()`.
- *
- * @example
- * // Background handler
- * await suspend();
- * console.log(await state()); // "suspended"
- */
-export async function suspend() {
-    const response = await send({ type: 'suspend' });
-    if (response.type !== 'suspend') {
-        throw new InvalidResponseError('suspend');
-    }
-}

package/dist/client/api/text-to-speech.d.ts

@@ -1,66 +0,0 @@
-import { type TtsClientParamsInput, type RPCOptions, type TtsResponse, type TextToSpeechStreamClientParams, type TextToSpeechStreamSession, type TextToSpeechStreamResult } from '../../schemas/index.js';
-/**
- * Fan-out queue that lets multiple consumers iterate the same TTS response
- * stream independently. Items are retained only until every active subscriber
- * has consumed them, then trimmed from the queue.
- *
- * The source is injected as an `AsyncIterable<TtsResponse>` so this class can
- * be unit-tested directly against the real implementation (without mocking
- * the RPC layer). Production callsites adapt `streamRpc(...)` via
- * `ttsResponseSource()` below.
- *
- * Exported for test use; not part of the public SDK surface.
- */
-export declare class TtsMulticast {
-    private readonly queue;
-    private readonly waiters;
-    private readonly subscriberIndexes;
-    private ended;
-    private fatal;
-    private readonly resolvePumpDone;
-    private readonly rejectPumpDone;
-    readonly done: Promise<boolean>;
-    constructor(source: AsyncIterable<TtsResponse>);
-    subscribe(): AsyncGenerator<TtsResponse>;
-    private notify;
-    private trimConsumed;
-    private unsubscribe;
-    private pump;
-    private drain;
-}
-/**
- * Converts text to speech audio using a loaded TTS model.
- *
- * Three modes selected by `params.stream` and `params.sentenceStream`:
- *
- * - `stream: false` (default) — collect all PCM samples and resolve once via
- *   `result.buffer` (`Promise<number[]>`). `bufferStream` is empty.
- * - `stream: true` — yield PCM samples through `result.bufferStream`
- *   (`AsyncGenerator<number>`) as they arrive. `buffer` resolves to an empty
- *   array.
- * - `stream: true, sentenceStream: true` — also exposes `result.chunkUpdates`
- *   (`AsyncGenerator<TtsSentenceChunkUpdate>`) so callers can mux per-sentence
- *   metadata with the audio. Multiple consumers can iterate the response
- *   independently via the underlying `TtsMulticast`.
- *
- * `result.done` resolves to `true` when synthesis completes cleanly, `false`
- * if the consumer breaks out before the terminal frame, or rejects on a
- * pipeline error. Awaiting `done` is safe even when no stream is iterated.
- *
- * @param params - TTS request parameters (see `TtsClientParamsInput`).
- * @param options - Optional RPC options (timeout, profiling, force new connection).
- * @returns A `TextToSpeechStreamResult` with `bufferStream`, `buffer`, `done`,
- *          and (when `sentenceStream: true`) `chunkUpdates`.
- * @throws {TextToSpeechStreamFailedError} When `sentenceStream: true` is paired
- *         with `stream: false`, or when the underlying RPC stream errors.
- */
-export declare function textToSpeech(params: TtsClientParamsInput, options?: RPCOptions): TextToSpeechStreamResult;
-export declare function encodeTextToSpeechFragment(textFragment: string | Uint8Array): Uint8Array<ArrayBufferLike>;
-/**
- * Duplex session: write UTF-8 text fragments (e.g. LLM token deltas) via `write`. Each string or
- * Uint8Array should be a complete UTF-8 fragment. The worker forwards them to ONNX TTS `runStreaming`
- * (optional sentence accumulation via request fields). Iterate the session for `TextToSpeechStreamResponse`
- * lines (PCM in `buffer`, optional `chunkIndex` / `sentenceChunk`) until `done`.
- */
-export declare function textToSpeechStream(params: TextToSpeechStreamClientParams, options?: RPCOptions): Promise<TextToSpeechStreamSession>;
-//# sourceMappingURL=text-to-speech.d.ts.map