@qvac/sdk 0.14.1 → 0.16.0

package/dist/client/api/text-to-speech.js

@@ -1,8 +1,8 @@
-import { textToSpeechStreamResponseSchema, ttsClientParamsSchema, } from "../../schemas/index.js";
-import { stream as streamRpc, duplex } from "../rpc/rpc-client.js";
-import { getClientLogger } from "../../logging/index.js";
-import { TextToSpeechStreamFailedError } from "../../utils/errors-client.js";
-import { parseClientInput } from "../parse-input.js";
+import { textToSpeechStreamResponseSchema, ttsClientParamsSchema } from '../../schemas/index.js';
+import { stream as streamRpc, duplex } from '../rpc/rpc-client.js';
+import { getClientLogger } from '../../logging/index.js';
+import { TextToSpeechStreamFailedError } from '../../utils/errors-client.js';
+import { parseClientInput } from '../parse-input.js';
 const logger = getClientLogger();
 /**
  * Fan-out queue that lets multiple consumers iterate the same TTS response
@@ -131,37 +131,37 @@ export class TtsMulticast {
 }
 function buildTtsRequest(params) {
     return {
-        type: "textToSpeech",
+        type: 'textToSpeech',
         modelId: params.modelId,
         inputType: params.inputType,
         text: params.text,
         stream: params.stream,
         sentenceStream: params.sentenceStream,
         ...(params.sentenceStreamLocale !== undefined && {
-            sentenceStreamLocale: params.sentenceStreamLocale,
+            sentenceStreamLocale: params.sentenceStreamLocale
         }),
         ...(params.sentenceStreamMaxChunkScalars !== undefined && {
-            sentenceStreamMaxChunkScalars: params.sentenceStreamMaxChunkScalars,
-        }),
+            sentenceStreamMaxChunkScalars: params.sentenceStreamMaxChunkScalars
+        })
     };
 }
 function buildTextToSpeechStreamRequest(params) {
     return {
-        type: "textToSpeechStream",
+        type: 'textToSpeechStream',
         modelId: params.modelId,
-        inputType: params.inputType ?? "text",
+        inputType: params.inputType ?? 'text',
         ...(params.accumulateSentences !== undefined && {
-            accumulateSentences: params.accumulateSentences,
+            accumulateSentences: params.accumulateSentences
         }),
         ...(params.sentenceDelimiterPreset !== undefined && {
-            sentenceDelimiterPreset: params.sentenceDelimiterPreset,
+            sentenceDelimiterPreset: params.sentenceDelimiterPreset
         }),
         ...(params.maxBufferScalars !== undefined && {
-            maxBufferScalars: params.maxBufferScalars,
+            maxBufferScalars: params.maxBufferScalars
         }),
         ...(params.flushAfterMs !== undefined && {
-            flushAfterMs: params.flushAfterMs,
-        }),
+            flushAfterMs: params.flushAfterMs
+        })
     };
 }
 /**
@@ -193,7 +193,7 @@ function buildTextToSpeechStreamRequest(params) {
 export function textToSpeech(params, options) {
     const parsed = parseClientInput(ttsClientParamsSchema, params);
     if (parsed.sentenceStream && !parsed.stream) {
-        throw new TextToSpeechStreamFailedError("textToSpeech: `sentenceStream: true` requires `stream: true`");
+        throw new TextToSpeechStreamFailedError('textToSpeech: `sentenceStream: true` requires `stream: true`');
     }
     const request = buildTtsRequest(parsed);
     if (parsed.stream && parsed.sentenceStream) {
@@ -209,7 +209,7 @@ export function textToSpeech(params, options) {
 // constructed in tests with a hand-rolled source instead.
 async function* ttsResponseSource(request, options) {
     for await (const response of streamRpc(request, options)) {
-        if (response.type !== "textToSpeech")
+        if (response.type !== 'textToSpeech')
             continue;
         yield response;
     }
@@ -227,7 +227,7 @@ function sentenceStreamTts(request, options) {
         bufferStream: sentenceBufferStream(bufferSubscription),
         chunkUpdates: sentenceChunkUpdates(chunkSubscription),
         buffer: Promise.resolve([]),
-        done: multicast.done,
+        done: multicast.done
     };
 }
 async function* sentenceBufferStream(source) {
@@ -243,14 +243,14 @@ async function* sentenceChunkUpdates(source) {
     for await (const m of source) {
         const hasAudio = m.buffer.length > 0;
         const hasMeta = m.chunkIndex !== undefined ||
-            (typeof m.sentenceChunk === "string" && m.sentenceChunk.length > 0);
+            (typeof m.sentenceChunk === 'string' && m.sentenceChunk.length > 0);
         if (hasAudio || hasMeta) {
             yield {
                 buffer: hasAudio ? [...m.buffer] : [],
                 ...(m.chunkIndex !== undefined ? { chunkIndex: m.chunkIndex } : {}),
-                ...(typeof m.sentenceChunk === "string" && m.sentenceChunk.length > 0
+                ...(typeof m.sentenceChunk === 'string' && m.sentenceChunk.length > 0
                     ? { sentenceChunk: m.sentenceChunk }
-                    : {}),
+                    : {})
             };
         }
         if (m.done)
@@ -268,14 +268,14 @@ function plainStreamTts(request, options) {
     return {
         bufferStream: plainTtsBufferStream(request, options, resolveDone, rejectDone),
         buffer: Promise.resolve([]),
-        done,
+        done
     };
 }
 async function* plainTtsBufferStream(request, options, resolveDone, rejectDone) {
     let settled = false;
     try {
         for await (const response of streamRpc(request, options)) {
-            if (response.type !== "textToSpeech")
+            if (response.type !== 'textToSpeech')
                 continue;
             // See TtsMulticast.pump — skip per-frame Zod validation; the server is
             // the source of truth for this wire shape.
@@ -313,7 +313,7 @@ function collectTts(request, options) {
     return {
         bufferStream: emptyBufferStream(),
         buffer: collectTtsBuffer(request, options, resolveDone, rejectDone),
-        done,
+        done
     };
 }
 async function* emptyBufferStream() {
@@ -323,7 +323,7 @@ async function collectTtsBuffer(request, options, resolveDone, rejectDone) {
     let buffer = [];
     try {
         for await (const response of streamRpc(request, options)) {
-            if (response.type !== "textToSpeech")
+            if (response.type !== 'textToSpeech')
                 continue;
             buffer = buffer.concat(response.buffer);
             if (response.done) {
@@ -356,11 +356,9 @@ export async function textToSpeechStream(params, options) {
     return {
         write(textFragment) {
             if (closed) {
-                throw new TextToSpeechStreamFailedError("TextToSpeechStreamSession.write() called after end()/destroy()");
+                throw new TextToSpeechStreamFailedError('TextToSpeechStreamSession.write() called after end()/destroy()');
             }
-            const buf = typeof textFragment === "string"
-                ? Buffer.from(textFragment, "utf8")
-                : textFragment;
+            const buf = typeof textFragment === 'string' ? Buffer.from(textFragment, 'utf8') : textFragment;
             requestStream.write(buf);
         },
         end() {
@@ -382,21 +380,21 @@ export async function textToSpeechStream(params, options) {
                 // protocol (which callers commonly forget to wrap in try/catch).
                 return {
                     next() {
-                        return Promise.reject(new TextToSpeechStreamFailedError("TextToSpeechStreamSession can only be iterated once"));
-                    },
+                        return Promise.reject(new TextToSpeechStreamFailedError('TextToSpeechStreamSession can only be iterated once'));
+                    }
                 };
             }
             consumed = true;
             return responses;
-        },
+        }
     };
 }
 async function* parseTextToSpeechStreamLines(responseStream) {
-    let buf = "";
+    let buf = '';
     for await (const chunk of responseStream) {
         buf += chunk.toString();
-        const lines = buf.split("\n");
-        buf = lines.pop() || "";
+        const lines = buf.split('\n');
+        buf = lines.pop() || '';
         for (const line of lines) {
             const yielded = processTextToSpeechStreamLine(line);
             if (yielded === undefined)
@@ -424,12 +422,12 @@ function processTextToSpeechStreamLine(line) {
         parsed = JSON.parse(line);
     }
     catch {
-        logger.warn("textToSpeechStream: malformed JSON from server:", line);
+        logger.warn('textToSpeechStream: malformed JSON from server:', line);
         return undefined;
     }
     const obj = parsed;
-    if (obj["type"] === "error") {
-        throw new TextToSpeechStreamFailedError(obj["message"] ?? "Unknown server error");
+    if (obj['type'] === 'error') {
+        throw new TextToSpeechStreamFailedError(obj['message'] ?? 'Unknown server error');
     }
     return textToSpeechStreamResponseSchema.parse(parsed);
 }

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

@@ -1,4 +1,4 @@
-import { type TranscribeClientParams, type RPCOptions, type TranscribeSegment, type TranscribeStreamClientParams, type TranscribeStreamSession, type TranscribeStreamMetadataSession, type TranscribeStreamConversationSession } from "../../schemas/index";
+import { type TranscribeClientParams, type RPCOptions, type TranscribeSegment, type TranscribeStreamClientParams, type TranscribeStreamSession, type TranscribeStreamMetadataSession, type TranscribeStreamConversationSession } from '../../schemas/index';
 /**
  * Transcribe audio and return the complete text. Accepts either a file
  * path or an audio buffer.
@@ -67,7 +67,7 @@ export declare function transcribeStream(params: TranscribeStreamClientParams &
     emitVadEvents: true;
 }, options?: RPCOptions): Promise<TranscribeStreamConversationSession>;
 export declare function transcribeStream(params: TranscribeStreamClientParams & {
-    parakeetStreamingConfig: NonNullable<TranscribeStreamClientParams["parakeetStreamingConfig"]>;
+    parakeetStreamingConfig: NonNullable<TranscribeStreamClientParams['parakeetStreamingConfig']>;
 }, options?: RPCOptions): Promise<TranscribeStreamConversationSession>;
 export declare function transcribeStream(params: TranscribeStreamClientParams & {
     metadata: true;

package/dist/client/api/transcribe.js

@@ -1,20 +1,20 @@
-import { transcribeResponseSchema, transcribeStreamResponseSchema, } from "../../schemas/index.js";
-import { stream, duplex } from "../rpc/rpc-client.js";
-import { getClientLogger } from "../../logging/index.js";
-import { TranscriptionFailedError } from "../../utils/errors-client.js";
-import { decoratePromise } from "../../utils/decorate-promise.js";
-import { generateClientRequestId } from "./client-request-id.js";
+import { transcribeResponseSchema, transcribeStreamResponseSchema } from '../../schemas/index.js';
+import { stream, duplex } from '../rpc/rpc-client.js';
+import { getClientLogger } from '../../logging/index.js';
+import { TranscriptionFailedError } from '../../utils/errors-client.js';
+import { decoratePromise } from '../../utils/decorate-promise.js';
+import { generateClientRequestId } from './client-request-id.js';
 const logger = getClientLogger();
 function buildTranscribeRequest(params, requestId) {
     return {
-        type: "transcribe",
+        type: 'transcribe',
         modelId: params.modelId,
-        audioChunk: typeof params.audioChunk === "string"
-            ? { type: "filePath", value: params.audioChunk }
-            : { type: "base64", value: params.audioChunk.toString("base64") },
+        audioChunk: typeof params.audioChunk === 'string'
+            ? { type: 'filePath', value: params.audioChunk }
+            : { type: 'base64', value: params.audioChunk.toString('base64') },
         ...(params.prompt && { prompt: params.prompt }),
         ...(params.metadata === true && { metadata: true }),
-        requestId,
+        requestId
     };
 }
 export function transcribe(params, options) {
@@ -32,7 +32,7 @@ async function runTranscribe(params, requestId, options) {
     if (params.metadata === true) {
         const segments = [];
         for await (const response of stream(request, options)) {
-            if (response.type === "transcribe") {
+            if (response.type === 'transcribe') {
                 const parsed = transcribeResponseSchema.parse(response);
                 if (parsed.segment) {
                     segments.push(parsed.segment);
@@ -44,9 +44,9 @@ async function runTranscribe(params, requestId, options) {
         }
         return segments;
     }
-    let fullText = "";
+    let fullText = '';
     for await (const response of stream(request, options)) {
-        if (response.type === "transcribe") {
+        if (response.type === 'transcribe') {
             const parsed = transcribeResponseSchema.parse(response);
             if (parsed.text) {
                 fullText += parsed.text;
@@ -59,16 +59,15 @@ async function runTranscribe(params, requestId, options) {
     return fullText;
 }
 export function transcribeStream(params, options) {
-    if ("audioChunk" in params && params.audioChunk !== undefined) {
-        logger.warn("transcribeStream() with audioChunk is deprecated — use transcribe() instead.");
+    if ('audioChunk' in params && params.audioChunk !== undefined) {
+        logger.warn('transcribeStream() with audioChunk is deprecated — use transcribe() instead.');
         if (params.metadata === true) {
             return transcribeStreamWithAudioMetadata(params, options);
         }
         return transcribeStreamWithAudio(params, options);
     }
     const streamParams = params;
-    if (streamParams.emitVadEvents === true ||
-        streamParams.parakeetStreamingConfig !== undefined) {
+    if (streamParams.emitVadEvents === true || streamParams.parakeetStreamingConfig !== undefined) {
         return transcribeStreamDuplexConversation(streamParams, options);
     }
     if (streamParams.metadata === true) {
@@ -83,7 +82,7 @@ export function transcribeStream(params, options) {
 async function* streamTranscribeValues(params, options, extract) {
     const request = buildTranscribeRequest(params, generateClientRequestId());
     for await (const response of stream(request, options)) {
-        if (response.type === "transcribe") {
+        if (response.type === 'transcribe') {
             const parsed = transcribeResponseSchema.parse(response);
             const value = extract(parsed);
             if (value !== undefined)
@@ -101,20 +100,20 @@ function transcribeStreamWithAudioMetadata(params, options) {
 }
 function buildTranscribeStreamRequest(params) {
     return {
-        type: "transcribeStream",
+        type: 'transcribeStream',
         modelId: params.modelId,
         ...(params.prompt && { prompt: params.prompt }),
         ...(params.metadata === true && { metadata: true }),
         ...(params.emitVadEvents === true && { emitVadEvents: true }),
         ...(params.endOfTurnSilenceMs !== undefined && {
-            endOfTurnSilenceMs: params.endOfTurnSilenceMs,
+            endOfTurnSilenceMs: params.endOfTurnSilenceMs
         }),
         ...(params.vadRunIntervalMs !== undefined && {
-            vadRunIntervalMs: params.vadRunIntervalMs,
+            vadRunIntervalMs: params.vadRunIntervalMs
         }),
         ...(params.parakeetStreamingConfig && {
-            parakeetStreamingConfig: params.parakeetStreamingConfig,
-        }),
+            parakeetStreamingConfig: params.parakeetStreamingConfig
+        })
     };
 }
 /**
@@ -144,18 +143,18 @@ async function createTranscribeStreamSession(params, options, process, sessionNa
             }
             consumed = true;
             return responses;
-        },
+        }
     };
 }
 function transcribeStreamDuplex(params, options) {
-    return createTranscribeStreamSession(params, options, processLine, "TranscribeStreamSession");
+    return createTranscribeStreamSession(params, options, processLine, 'TranscribeStreamSession');
 }
 function transcribeStreamDuplexMetadata(params, options) {
-    return createTranscribeStreamSession(params, options, processLineMetadata, "TranscribeStreamMetadataSession");
+    return createTranscribeStreamSession(params, options, processLineMetadata, 'TranscribeStreamMetadataSession');
 }
 function transcribeStreamDuplexConversation(params, options) {
     const wantsMetadata = params.metadata === true;
-    return createTranscribeStreamSession(params, options, (line) => processLineConversation(line, wantsMetadata), "TranscribeStreamConversationSession");
+    return createTranscribeStreamSession(params, options, (line) => processLineConversation(line, wantsMetadata), 'TranscribeStreamConversationSession');
 }
 /**
  * Line-delimited parser: reads newline-separated frames from a duplex
@@ -163,11 +162,11 @@ function transcribeStreamDuplexConversation(params, options) {
  * whatever values it returns. `null` from `process` terminates the stream.
  */
 async function* parseLines(responseStream, process) {
-    let buf = "";
+    let buf = '';
     for await (const chunk of responseStream) {
         buf += chunk.toString();
-        const lines = buf.split("\n");
-        buf = lines.pop() || "";
+        const lines = buf.split('\n');
+        buf = lines.pop() || '';
         for (const line of lines) {
             const result = process(line);
             if (result === null)
@@ -191,12 +190,12 @@ function parseResponseLine(line) {
         parsed = JSON.parse(line);
     }
     catch {
-        logger.warn("transcribeStream: malformed JSON from server:", line);
+        logger.warn('transcribeStream: malformed JSON from server:', line);
         return null;
     }
     const obj = parsed;
-    if (obj["type"] === "error") {
-        throw new TranscriptionFailedError(obj["message"] ?? "Unknown server error");
+    if (obj['type'] === 'error') {
+        throw new TranscriptionFailedError(obj['message'] ?? 'Unknown server error');
     }
     return transcribeStreamResponseSchema.parse(parsed);
 }
@@ -216,7 +215,7 @@ function processWith(line, extract) {
     return extract(response);
 }
 function processLine(line) {
-    return processWith(line, (response) => response.text?.trim() ? response.text : undefined);
+    return processWith(line, (response) => (response.text?.trim() ? response.text : undefined));
 }
 function processLineMetadata(line) {
     return processWith(line, (response) => response.segment);
@@ -225,32 +224,32 @@ function processLineConversation(line, wantsMetadata) {
     return processWith(line, (response) => {
         if (response.vad) {
             return {
-                type: "vad",
+                type: 'vad',
                 speaking: response.vad.speaking,
-                probability: response.vad.probability,
+                probability: response.vad.probability
             };
         }
         if (response.endOfTurn) {
-            if (response.endOfTurn.source === "whisper") {
+            if (response.endOfTurn.source === 'whisper') {
                 return {
-                    type: "endOfTurn",
-                    source: "whisper",
-                    silenceDurationMs: response.endOfTurn.silenceDurationMs,
+                    type: 'endOfTurn',
+                    source: 'whisper',
+                    silenceDurationMs: response.endOfTurn.silenceDurationMs
                 };
             }
             return {
-                type: "endOfTurn",
-                source: "parakeet",
+                type: 'endOfTurn',
+                source: 'parakeet'
             };
         }
         if (wantsMetadata) {
             if (response.segment) {
-                return { type: "segment", segment: response.segment };
+                return { type: 'segment', segment: response.segment };
             }
             return undefined;
         }
         if (response.text && response.text.trim()) {
-            return { type: "text", text: response.text };
+            return { type: 'text', text: response.text };
         }
         return undefined;
     });

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

@@ -1,4 +1,4 @@
-import { type TranslateClientParams, type TranslationStats, type RPCOptions } from "../../schemas/index";
+import { type TranslateClientParams, type TranslationStats, type RPCOptions } from '../../schemas/index';
 /**
  * Translates text from one language to another using a specified translation model.
  * Supports both NMT (Neural Machine Translation) and LLM models.

package/dist/client/api/translate.js

@@ -1,7 +1,5 @@
-import { stream as streamRpc } from "../rpc/rpc-client.js";
-import { translateResponseSchema, normalizeModelType, ModelType, } from "../../schemas/index.js";
-import { detectOne } from "@qvac/langdetect-text";
-import { TranslationFailedError } from "../../utils/errors-client.js";
+import { stream as streamRpc } from '../rpc/rpc-client.js';
+import { translateResponseSchema } from '../../schemas/index.js';
 /**
  * Translates text from one language to another using a specified translation model.
  * Supports both NMT (Neural Machine Translation) and LLM models.
@@ -44,22 +42,13 @@ import { TranslationFailedError } from "../../utils/errors-client.js";
  * ```
  */
 export function translate(params, options) {
-    const canonicalModelType = normalizeModelType(params.modelType);
-    const isLlm = canonicalModelType === ModelType.llamacppCompletion;
-    let sourceLanguage = isLlm ? params.from : undefined;
-    if (!sourceLanguage && isLlm) {
-        const detected = detectOne(params.text);
-        if (detected.code === "und" || detected.language === "Undetermined") {
-            throw new TranslationFailedError("Could not detect the source language. Please specify the 'from' parameter explicitly.");
-        }
-        sourceLanguage = detected.language;
-    }
+    // Source-language auto-detection lives in the worker now
+    // (server/bare/ops/translate.ts): `from` is passed through when present and
+    // resolved server-side when absent, so every language binding shares one
+    // detector instead of each shipping its own.
     const request = {
-        type: "translate",
-        ...params,
-        ...(isLlm && {
-            from: sourceLanguage,
-        }),
+        type: 'translate',
+        ...params
     };
     let stats;
     let statsResolver = () => { };
@@ -69,7 +58,7 @@ export function translate(params, options) {
     if (params.stream) {
         const tokenStream = (async function* () {
             for await (const response of streamRpc(request, options)) {
-                if (response.type === "translate") {
+                if (response.type === 'translate') {
                     const streamResponse = translateResponseSchema.parse(response);
                     if (!streamResponse.done) {
                         yield streamResponse.token;
@@ -81,11 +70,11 @@ export function translate(params, options) {
                 }
             }
         })();
-        const textPromise = Promise.resolve("");
+        const textPromise = Promise.resolve('');
         return {
             tokenStream,
             text: textPromise,
-            stats: statsPromise,
+            stats: statsPromise
         };
     }
     else {
@@ -93,9 +82,9 @@ export function translate(params, options) {
             //Empty generator for non-streaming mode
         })();
         const textPromise = (async () => {
-            let buffer = "";
+            let buffer = '';
             for await (const response of streamRpc(request, options)) {
-                if (response.type === "translate") {
+                if (response.type === 'translate') {
                     const streamResponse = translateResponseSchema.parse(response);
                     buffer += streamResponse.token;
                     if (streamResponse.done) {
@@ -109,7 +98,7 @@ export function translate(params, options) {
         return {
             tokenStream,
             text: textPromise,
-            stats: statsPromise,
+            stats: statsPromise
         };
     }
 }

package/dist/client/api/unload-model.d.ts

@@ -1,4 +1,4 @@
-import { type UnloadModelParams } from "../../schemas/index";
+import { type UnloadModelParams } from '../../schemas/index';
 /**
  * Unloads a previously loaded model from the server.
  *

package/dist/client/api/unload-model.js

@@ -1,9 +1,9 @@
-import { isBare } from "which-runtime";
-import {} from "../../schemas/index.js";
-import { send, close } from "../rpc/rpc-client.js";
-import { stopLoggingStreamForModel } from "../logging-stream-registry.js";
-import { InvalidResponseError, ModelUnloadFailedError, } from "../../utils/errors-client.js";
-import { getClientLogger } from "../../logging/index.js";
+import { isBare } from 'which-runtime';
+import {} from '../../schemas/index.js';
+import { send, close } from '../rpc/rpc-client.js';
+import { stopLoggingStreamForModel } from '../logging-stream-registry.js';
+import { InvalidResponseError, ModelUnloadFailedError } from '../../utils/errors-client.js';
+import { getClientLogger } from '../../logging/index.js';
 const logger = getClientLogger();
 /**
  * Unloads a previously loaded model from the server.
@@ -22,13 +22,13 @@ const logger = getClientLogger();
  */
 export async function unloadModel(params) {
     const request = {
-        type: "unloadModel",
+        type: 'unloadModel',
         modelId: params.modelId,
-        clearStorage: params.clearStorage ?? false,
+        clearStorage: params.clearStorage ?? false
     };
     const response = await send(request);
-    if (response.type !== "unloadModel") {
-        throw new InvalidResponseError("unloadModel");
+    if (response.type !== 'unloadModel') {
+        throw new InvalidResponseError('unloadModel');
     }
     if (!response.success) {
         throw new ModelUnloadFailedError(params.modelId);
@@ -38,7 +38,7 @@ export async function unloadModel(params) {
     if (shouldAutoClose &&
         response.hasActiveModels === false &&
         response.hasActiveProviders === false) {
-        logger.info("🧹 No models or providers active, automatically closing RPC connection...");
+        logger.info('🧹 No models or providers active, automatically closing RPC connection...');
         await close();
     }
 }

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

@@ -1,4 +1,4 @@
-import { type UpscaleClientParams, type UpscaleStats } from "../../schemas/sdcpp-config";
+import { type UpscaleClientParams, type UpscaleStats } from '../../schemas/sdcpp-config';
 interface UpscaleResult {
     outputs: Promise<Uint8Array[]>;
     stats: Promise<UpscaleStats | undefined>;

package/dist/client/api/upscale.js

@@ -1,7 +1,7 @@
-import { upscaleStreamResponseSchema, } from "../../schemas/sdcpp-config.js";
-import { stream as streamRpc } from "../rpc/rpc-client.js";
-import { decodeBase64, encodeBase64 } from "../../utils/encoding.js";
-import { StreamEndedError } from "../../utils/errors-client.js";
+import { upscaleStreamResponseSchema } from '../../schemas/sdcpp-config.js';
+import { stream as streamRpc } from '../rpc/rpc-client.js';
+import { decodeBase64, encodeBase64 } from '../../utils/encoding.js';
+import { StreamEndedError } from '../../utils/errors-client.js';
 /**
  * Runs standalone ESRGAN upscaling on an arbitrary PNG/JPEG image.
  *
@@ -44,7 +44,7 @@ export function upscale(params) {
         modelId: params.modelId,
         image: encodeBase64(params.image),
         ...(params.repeats !== undefined && { repeats: params.repeats }),
-        type: "upscaleStream",
+        type: 'upscaleStream'
     };
     let statsResolver = () => { };
     let statsRejecter = () => { };
@@ -66,9 +66,9 @@ export function upscale(params) {
         try {
             for await (const response of streamRpc(request)) {
                 if (response &&
-                    typeof response === "object" &&
-                    "type" in response &&
-                    response.type === "upscaleStream") {
+                    typeof response === 'object' &&
+                    'type' in response &&
+                    response.type === 'upscaleStream') {
                     const parsed = upscaleStreamResponseSchema.parse(response);
                     if (parsed.data) {
                         collectedBuffers.push(decodeBase64(parsed.data));
@@ -94,6 +94,6 @@ export function upscale(params) {
     void processResponses();
     return {
         outputs: outputsPromise,
-        stats: statsPromise,
+        stats: statsPromise
     };
 }

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

@@ -1,4 +1,4 @@
-import { type VideoClientParams, type VideoStats } from "../../schemas/index";
+import { type VideoClientParams, type VideoStats } from '../../schemas/index';
 export interface VideoProgressTick {
     step: number;
     totalSteps: number;
@@ -16,10 +16,13 @@ export interface VideoResult {
  * @param params - Video request parameters (model, prompt, dimensions, frame count, fps, sampler, seed, etc.).
  * @returns A result object exposing `requestId` (stable identifier for this in-flight generation), `progressStream` (async iterator of `{ step, totalSteps, elapsedMs }`), `outputs` (promise of the generated video buffers, typically a single AVI file), and `stats` (promise of generation statistics).
  *
- * Supports `txt2vid` (text-to-video) and `img2vid` (image-to-video). For `img2vid`,
- * load the Wan pipeline with `modelConfig.clipVisionModelSrc` set to
- * `clip_vision_h.safetensors`. On React Native, prefer a `modelId` loaded with a
- * `delegate` since the bundled video diffusion models are too large for typical mobile devices.
+ * Supports `txt2vid` (text-to-video) and `img2vid` (image-to-video) for both the
+ * Wan and LTX-2 layouts. For Wan `img2vid`, load the pipeline with
+ * `modelConfig.clipVisionModelSrc` set to `clip_vision_h.safetensors`; LTX-2
+ * `img2vid` conditions on the first frame through its video VAE and needs no
+ * CLIP vision weights (the same LTX-2 model loaded for txt2vid also does
+ * img2vid). On React Native, prefer a `modelId` loaded with a `delegate` since
+ * the bundled video diffusion models are too large for typical mobile devices.
  *
  * @example Basic txt2vid generation
  * ```typescript