@qvac/sdk 0.12.1 → 0.13.0

package/dist/models/update-models/companions.d.ts

@@ -13,6 +13,13 @@ import type { ProcessedModel } from "./types";
  *   Bergamot NMT sets (directory-based):
  *     Primary: `model.<langPair>.intgemm.alphas.bin`
  *     Companions in same directory: lex, vocab/srcvocab+trgvocab, metadata
+ *
+ *   BCI whisper.cpp sets (directory-based):
+ *     Primary: `ggml-bci-windowed.bin`
+ *     Companion in same directory: `bci-embedder.bin`
+ *     The addon resolves the embedder by exact filename next to the model
+ *     (`dirname(model)/bci-embedder.bin`), so the two files must be
+ *     physically co-located — which the companion-set cache layout guarantees.
  */
 export declare function groupCompanionSets(models: ProcessedModel[]): ProcessedModel[];
 //# sourceMappingURL=companions.d.ts.map

package/dist/models/update-models/companions.js

@@ -14,6 +14,13 @@ import { BERGAMOT_MODEL_RE } from "../../schemas/index.js";
  *   Bergamot NMT sets (directory-based):
  *     Primary: `model.<langPair>.intgemm.alphas.bin`
  *     Companions in same directory: lex, vocab/srcvocab+trgvocab, metadata
+ *
+ *   BCI whisper.cpp sets (directory-based):
+ *     Primary: `ggml-bci-windowed.bin`
+ *     Companion in same directory: `bci-embedder.bin`
+ *     The addon resolves the embedder by exact filename next to the model
+ *     (`dirname(model)/bci-embedder.bin`), so the two files must be
+ *     physically co-located — which the companion-set cache layout guarantees.
  */
 export function groupCompanionSets(models) {
     const bySourcePath = new Map();
@@ -23,6 +30,7 @@ export function groupCompanionSets(models) {
     const companionKeys = new Set();
     groupOnnxCompanions(models, bySourcePath, companionKeys);
     groupBergamotCompanions(models, bySourcePath, companionKeys);
+    groupBciCompanions(models, bySourcePath, companionKeys);
     return models.map((model) => {
         const key = sourceKey(model.registrySource, model.registryPath);
         if (companionKeys.has(key)) {
@@ -126,6 +134,54 @@ function groupBergamotCompanions(models, bySourcePath, companionKeys) {
         };
     }
 }
+const BCI_PRIMARY_FILENAME = "ggml-bci-windowed.bin";
+const BCI_EMBEDDER_FILENAME = "bci-embedder.bin";
+function groupBciCompanions(models, bySourcePath, companionKeys) {
+    for (const model of models) {
+        const filename = model.registryPath.split("/").pop();
+        if (filename !== BCI_PRIMARY_FILENAME)
+            continue;
+        const lastSep = model.registryPath.lastIndexOf("/");
+        const dirPrefix = lastSep >= 0 ? model.registryPath.slice(0, lastSep + 1) : "";
+        const source = model.registrySource;
+        const embedderPath = `${dirPrefix}${BCI_EMBEDDER_FILENAME}`;
+        const embedder = bySourcePath.get(sourceKey(source, embedderPath));
+        if (!embedder)
+            continue;
+        const setKey = shortHash(`${source}:${model.registryPath}`);
+        const primaryEntry = {
+            key: "modelPath",
+            registryPath: model.registryPath,
+            registrySource: source,
+            targetName: BCI_PRIMARY_FILENAME,
+            expectedSize: model.expectedSize,
+            sha256Checksum: model.sha256Checksum,
+            blobCoreKey: model.blobCoreKey,
+            blobBlockOffset: model.blobBlockOffset,
+            blobBlockLength: model.blobBlockLength,
+            blobByteOffset: model.blobByteOffset,
+            primary: true,
+        };
+        const embedderEntry = {
+            key: "embedderPath",
+            registryPath: embedder.registryPath,
+            registrySource: embedder.registrySource,
+            targetName: BCI_EMBEDDER_FILENAME,
+            expectedSize: embedder.expectedSize,
+            sha256Checksum: embedder.sha256Checksum,
+            blobCoreKey: embedder.blobCoreKey,
+            blobBlockOffset: embedder.blobBlockOffset,
+            blobBlockLength: embedder.blobBlockLength,
+            blobByteOffset: embedder.blobByteOffset,
+        };
+        model.companionSet = {
+            setKey,
+            primaryKey: "modelPath",
+            files: [primaryEntry, embedderEntry],
+        };
+        companionKeys.add(sourceKey(embedder.registrySource, embedder.registryPath));
+    }
+}
 function findBergamotCompanions(source, dirPrefix, langPair, bySourcePath) {
     const found = [];
     const lexPath = `${dirPrefix}lex.50.50.${langPair}.s2t.bin`;

package/dist/models/update-models/naming.js

@@ -87,6 +87,8 @@ function generateBaseName(input) {
     switch (addon) {
         case "whisper":
             return generateWhisperName(input);
+        case "bci":
+            return generateBciName(input);
         case "vad":
             return generateVadName(input);
         case "nmt":
@@ -150,6 +152,14 @@ function generateWhisperName({ filename, lowerFilename, quantization, }) {
         nameParts.push(fileQuant);
     return `WHISPER_${nameParts.map(cleanPart).join("_")}`;
 }
+function generateBciName({ filename, quantization }) {
+    // Strip the engine/format prefix and a leading "BCI" token so role names
+    // like "bci-embedder.bin" / "ggml-bci-windowed.bin" become EMBEDDER /
+    // WINDOWED before we re-prefix with BCI_.
+    const role = cleanPart(filename.replace(/\.\w+$/, "")).replace(/^BCI_?/, "");
+    const nameParts = [role, quantization].filter((p) => p && p !== "");
+    return `BCI_${nameParts.map(cleanPart).join("_")}`;
+}
 function generateVadName({ filename, tagType, tagName, }) {
     const versionMatch = filename.match(/v(\d+\.\d+\.\d+)/i);
     const version = versionMatch ? versionMatch[1] : "";

package/dist/pear/pre.js

@@ -31,6 +31,7 @@ const BUILTIN_PLUGINS = [
     "@qvac/sdk/llamacpp-completion/plugin",
     "@qvac/sdk/llamacpp-embedding/plugin",
     "@qvac/sdk/whispercpp-transcription/plugin",
+    "@qvac/sdk/bci-whispercpp-transcription/plugin",
     "@qvac/sdk/nmtcpp-translation/plugin",
     "@qvac/sdk/tts-ggml/plugin",
     "@qvac/sdk/onnx-ocr/plugin",
@@ -42,6 +43,7 @@ const BUILTIN_PLUGIN_EXPORTS = {
     "llamacpp-completion": "llmPlugin",
     "llamacpp-embedding": "embeddingsPlugin",
     "whispercpp-transcription": "whisperPlugin",
+    "bci-whispercpp-transcription": "bciPlugin",
     "nmtcpp-translation": "nmtPlugin",
     "tts-ggml": "ttsPlugin",
     "onnx-ocr": "ocrPlugin",

package/dist/schemas/bci-config.d.ts

@@ -0,0 +1,36 @@
+import { z } from "zod";
+export declare const bciConfigSchema: z.ZodObject<{
+    whisperConfig: z.ZodOptional<z.ZodObject<{
+        language: z.ZodOptional<z.ZodString>;
+        n_threads: z.ZodOptional<z.ZodNumber>;
+        temperature: z.ZodOptional<z.ZodNumber>;
+        suppress_nst: z.ZodOptional<z.ZodBoolean>;
+        suppress_blank: z.ZodOptional<z.ZodBoolean>;
+        duration_ms: z.ZodOptional<z.ZodNumber>;
+        translate: z.ZodOptional<z.ZodBoolean>;
+        no_timestamps: z.ZodOptional<z.ZodBoolean>;
+        single_segment: z.ZodOptional<z.ZodBoolean>;
+        print_special: z.ZodOptional<z.ZodBoolean>;
+        print_progress: z.ZodOptional<z.ZodBoolean>;
+        print_realtime: z.ZodOptional<z.ZodBoolean>;
+        print_timestamps: z.ZodOptional<z.ZodBoolean>;
+        detect_language: z.ZodOptional<z.ZodBoolean>;
+        greedy_best_of: z.ZodOptional<z.ZodNumber>;
+        beam_search_beam_size: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    bciConfig: z.ZodOptional<z.ZodObject<{
+        day_idx: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    contextParams: z.ZodOptional<z.ZodObject<{
+        model: z.ZodOptional<z.ZodString>;
+        use_gpu: z.ZodOptional<z.ZodBoolean>;
+        flash_attn: z.ZodOptional<z.ZodBoolean>;
+        gpu_device: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    miscConfig: z.ZodOptional<z.ZodObject<{
+        caption_enabled: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    backendsDir: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type BciConfig = z.infer<typeof bciConfigSchema>;
+//# sourceMappingURL=bci-config.d.ts.map

package/dist/schemas/bci-config.js

@@ -0,0 +1,56 @@
+import { z } from "zod";
+// === BCI (whisper.cpp) engine config ===
+//
+// Mirrors `BCIWhispercppConfig` from `@qvac/bci-whispercpp`. Unlike the
+// flat `whisperConfigSchema`, the BCI addon nests its inference knobs
+// under `whisperConfig` and exposes a separate `bciConfig` for
+// session-level (neural-signal) parameters.
+// Reduced whisper inference field set exposed by the BCI addon (see the
+// `WhisperConfig` interface in `@qvac/bci-whispercpp`).
+const bciWhisperConfigSchema = z
+    .object({
+    language: z.string().optional(),
+    n_threads: z.number().int().optional(),
+    temperature: z.number().optional(),
+    suppress_nst: z.boolean().optional(),
+    suppress_blank: z.boolean().optional(),
+    duration_ms: z.number().int().optional(),
+    translate: z.boolean().optional(),
+    no_timestamps: z.boolean().optional(),
+    single_segment: z.boolean().optional(),
+    print_special: z.boolean().optional(),
+    print_progress: z.boolean().optional(),
+    print_realtime: z.boolean().optional(),
+    print_timestamps: z.boolean().optional(),
+    detect_language: z.boolean().optional(),
+    greedy_best_of: z.number().int().optional(),
+    beam_search_beam_size: z.number().int().optional(),
+})
+    .optional();
+const bciSessionConfigSchema = z
+    .object({
+    // Session day index used to select day-specific projection matrices.
+    // `-1` enables mel passthrough (parity testing only).
+    day_idx: z.number().int().optional(),
+})
+    .optional();
+const bciContextParamsSchema = z
+    .object({
+    model: z.string().optional(),
+    use_gpu: z.boolean().optional(),
+    flash_attn: z.boolean().optional(),
+    gpu_device: z.number().optional(),
+})
+    .optional();
+const bciMiscConfigSchema = z
+    .object({
+    caption_enabled: z.boolean().optional(),
+})
+    .optional();
+export const bciConfigSchema = z.object({
+    whisperConfig: bciWhisperConfigSchema,
+    bciConfig: bciSessionConfigSchema,
+    contextParams: bciContextParamsSchema,
+    miscConfig: bciMiscConfigSchema,
+    backendsDir: z.string().optional(),
+});

package/dist/schemas/bci.d.ts

@@ -0,0 +1,177 @@
+import { z } from "zod";
+import { type TranscribeSegment } from "./transcription";
+export declare const neuralInputSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"base64">;
+    value: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"filePath">;
+    value: z.ZodString;
+}, z.core.$strip>], "type">;
+export declare const bciTranscribeParamsSchema: z.ZodObject<{
+    modelId: z.ZodString;
+    metadata: z.ZodOptional<z.ZodBoolean>;
+    neuralData: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"base64">;
+        value: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"filePath">;
+        value: z.ZodString;
+    }, z.core.$strip>], "type">;
+}, z.core.$strip>;
+export declare const bciTranscribeClientParamsSchema: z.ZodObject<{
+    modelId: z.ZodString;
+    metadata: z.ZodOptional<z.ZodBoolean>;
+    neuralData: z.ZodUnion<readonly [z.ZodString, z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>]>;
+}, z.core.$strip>;
+export declare const bciTranscribeRequestSchema: z.ZodObject<{
+    modelId: z.ZodString;
+    metadata: z.ZodOptional<z.ZodBoolean>;
+    neuralData: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"base64">;
+        value: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"filePath">;
+        value: z.ZodString;
+    }, z.core.$strip>], "type">;
+    type: z.ZodLiteral<"bciTranscribe">;
+    requestId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const bciTranscribeResponseSchema: z.ZodObject<{
+    text: z.ZodOptional<z.ZodString>;
+    done: z.ZodOptional<z.ZodBoolean>;
+    stats: z.ZodOptional<z.ZodObject<{
+        audioDuration: z.ZodOptional<z.ZodNumber>;
+        realTimeFactor: z.ZodOptional<z.ZodNumber>;
+        tokensPerSecond: z.ZodOptional<z.ZodNumber>;
+        totalTokens: z.ZodOptional<z.ZodNumber>;
+        totalSegments: z.ZodOptional<z.ZodNumber>;
+        whisperEncodeTime: z.ZodOptional<z.ZodNumber>;
+        whisperDecodeTime: z.ZodOptional<z.ZodNumber>;
+        encoderTime: z.ZodOptional<z.ZodNumber>;
+        decoderTime: z.ZodOptional<z.ZodNumber>;
+        melSpecTime: z.ZodOptional<z.ZodNumber>;
+        backendDevice: z.ZodOptional<z.ZodNumber>;
+        backendId: z.ZodOptional<z.ZodNumber>;
+        gpuMemTotalMb: z.ZodOptional<z.ZodNumber>;
+        gpuMemFreeMb: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    error: z.ZodOptional<z.ZodString>;
+    segment: z.ZodOptional<z.ZodObject<{
+        text: z.ZodString;
+        startMs: z.ZodNumber;
+        endMs: z.ZodNumber;
+        append: z.ZodBoolean;
+        id: z.ZodNumber;
+    }, z.core.$strip>>;
+    type: z.ZodLiteral<"bciTranscribe">;
+}, z.core.$strip>;
+/**
+ * Per-call overrides for the BCI addon's sliding-window streaming
+ * (`transcribeStream`). Each field maps 1:1 to the addon's `streamOpts`;
+ * any field omitted falls back to the addon default.
+ */
+export declare const bciStreamOptsSchema: z.ZodObject<{
+    windowTimesteps: z.ZodOptional<z.ZodNumber>;
+    hopTimesteps: z.ZodOptional<z.ZodNumber>;
+    emit: z.ZodOptional<z.ZodEnum<{
+        full: "full";
+        delta: "delta";
+    }>>;
+}, z.core.$strip>;
+export declare const bciTranscribeStreamRequestSchema: z.ZodObject<{
+    modelId: z.ZodString;
+    metadata: z.ZodOptional<z.ZodBoolean>;
+    type: z.ZodLiteral<"bciTranscribeStream">;
+    streamOpts: z.ZodOptional<z.ZodObject<{
+        windowTimesteps: z.ZodOptional<z.ZodNumber>;
+        hopTimesteps: z.ZodOptional<z.ZodNumber>;
+        emit: z.ZodOptional<z.ZodEnum<{
+            full: "full";
+            delta: "delta";
+        }>>;
+    }, z.core.$strip>>;
+    requestId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const bciTranscribeStreamResponseSchema: z.ZodObject<{
+    text: z.ZodOptional<z.ZodString>;
+    done: z.ZodOptional<z.ZodBoolean>;
+    stats: z.ZodOptional<z.ZodObject<{
+        audioDuration: z.ZodOptional<z.ZodNumber>;
+        realTimeFactor: z.ZodOptional<z.ZodNumber>;
+        tokensPerSecond: z.ZodOptional<z.ZodNumber>;
+        totalTokens: z.ZodOptional<z.ZodNumber>;
+        totalSegments: z.ZodOptional<z.ZodNumber>;
+        whisperEncodeTime: z.ZodOptional<z.ZodNumber>;
+        whisperDecodeTime: z.ZodOptional<z.ZodNumber>;
+        encoderTime: z.ZodOptional<z.ZodNumber>;
+        decoderTime: z.ZodOptional<z.ZodNumber>;
+        melSpecTime: z.ZodOptional<z.ZodNumber>;
+        backendDevice: z.ZodOptional<z.ZodNumber>;
+        backendId: z.ZodOptional<z.ZodNumber>;
+        gpuMemTotalMb: z.ZodOptional<z.ZodNumber>;
+        gpuMemFreeMb: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    error: z.ZodOptional<z.ZodString>;
+    segment: z.ZodOptional<z.ZodObject<{
+        text: z.ZodString;
+        startMs: z.ZodNumber;
+        endMs: z.ZodNumber;
+        append: z.ZodBoolean;
+        id: z.ZodNumber;
+    }, z.core.$strip>>;
+    type: z.ZodLiteral<"bciTranscribeStream">;
+}, z.core.$strip>;
+export type NeuralInput = z.infer<typeof neuralInputSchema>;
+export type BciTranscribeParams = z.infer<typeof bciTranscribeParamsSchema>;
+export type BciTranscribeRequest = z.infer<typeof bciTranscribeRequestSchema>;
+export type BciTranscribeResponse = z.infer<typeof bciTranscribeResponseSchema>;
+export type BciTranscribeClientParamsParsed = z.output<typeof bciTranscribeClientParamsSchema>;
+export type BciStreamOpts = z.infer<typeof bciStreamOptsSchema>;
+export type BciTranscribeStreamRequest = z.infer<typeof bciTranscribeStreamRequestSchema>;
+export type BciTranscribeStreamResponse = z.infer<typeof bciTranscribeStreamResponseSchema>;
+/** Client parameters for `bciTranscribe()`. */
+export interface BciTranscribeClientParams {
+    /** Identifier returned by `loadModel()` for a loaded BCI model. */
+    modelId: string;
+    /**
+     * BCI neural input. A string is treated as a local/provider `.bin` file path;
+     * a `Uint8Array` is treated as raw neural bytes and sent as base64 on the
+     * wire.
+     */
+    neuralData: string | Uint8Array;
+    /**
+     * When true, resolves to transcript segment metadata objects
+     * (`{ text, startMs, endMs, append, id }`) instead of joined text.
+     */
+    metadata?: boolean;
+}
+export type BciTranscribeStreamClientParams = {
+    modelId: string;
+    metadata?: boolean;
+    windowTimesteps?: number;
+    hopTimesteps?: number;
+    emit?: "delta" | "full";
+};
+export interface BciTranscribeStreamSession {
+    /**
+     * Stable id for this in-flight BCI stream. Pass to `cancel({ requestId })`
+     * to target this duplex session without cancelling other work on the model.
+     */
+    requestId: string;
+    write(neuralChunk: Uint8Array): void;
+    end(): void;
+    destroy(): void;
+    [Symbol.asyncIterator](): AsyncIterator<string>;
+}
+export interface BciTranscribeStreamMetadataSession {
+    /**
+     * Stable id for this in-flight BCI stream. Pass to `cancel({ requestId })`
+     * to target this duplex session without cancelling other work on the model.
+     */
+    requestId: string;
+    write(neuralChunk: Uint8Array): void;
+    end(): void;
+    destroy(): void;
+    [Symbol.asyncIterator](): AsyncIterator<TranscribeSegment>;
+}
+//# sourceMappingURL=bci.d.ts.map

package/dist/schemas/bci.js

@@ -0,0 +1,95 @@
+import { z } from "zod";
+import { transcribeSegmentSchema, transcribeStatsSchema, } from "./transcription.js";
+// Neural-signal binary input. The BCI addon consumes a raw neural buffer
+// (not audio): pass it inline as base64 or point at a local `.bin` file.
+export const neuralInputSchema = z.discriminatedUnion("type", [
+    z.object({
+        type: z.literal("base64").describe("Inline base64-encoded neural bytes."),
+        value: z
+            .string()
+            .describe("Base64-encoded contents of a BCI neural `.bin` recording."),
+    }),
+    z.object({
+        type: z.literal("filePath").describe("Local neural `.bin` file path."),
+        value: z
+            .string()
+            .describe("Path to a BCI neural `.bin` recording on the provider."),
+    }),
+]);
+const bciTranscribeBaseSchema = z.object({
+    modelId: z
+        .string()
+        .describe("Identifier returned by `loadModel()` for a loaded BCI model."),
+    metadata: z
+        .boolean()
+        .optional()
+        .describe("When true, responses yield transcript segment metadata objects (`{ text, startMs, endMs, append, id }`) instead of joined text."),
+});
+export const bciTranscribeParamsSchema = bciTranscribeBaseSchema.extend({
+    neuralData: neuralInputSchema.describe("Fixed wire shape for BCI neural input: either inline base64 neural bytes or a provider-local `.bin` file path."),
+});
+export const bciTranscribeClientParamsSchema = bciTranscribeBaseSchema.extend({
+    neuralData: z
+        .union([z.string(), z.instanceof(Uint8Array)])
+        .describe("Convenience client input for BCI neural data: pass a local/provider `.bin` file path as a string, or raw neural bytes as a `Uint8Array`. The client converts this to `neuralInputSchema` before sending the request."),
+});
+export const bciTranscribeRequestSchema = bciTranscribeParamsSchema.extend({
+    type: z.literal("bciTranscribe"),
+    requestId: z
+        .string()
+        .min(1)
+        .optional()
+        .describe("Stable identifier for this in-flight BCI transcription, generated by the client at call time. Surfaces on the registry so callers can target it with `cancel({ requestId })`. Optional on the wire — the server falls back to a server-generated id when the field is missing."),
+});
+const bciTranscriptionResultBase = z.object({
+    text: z.string().optional(),
+    done: z.boolean().optional(),
+    stats: transcribeStatsSchema.optional(),
+    error: z.string().optional(),
+    segment: transcribeSegmentSchema.optional(),
+});
+export const bciTranscribeResponseSchema = bciTranscriptionResultBase.extend({
+    type: z.literal("bciTranscribe"),
+});
+/**
+ * Per-call overrides for the BCI addon's sliding-window streaming
+ * (`transcribeStream`). Each field maps 1:1 to the addon's `streamOpts`;
+ * any field omitted falls back to the addon default.
+ */
+export const bciStreamOptsSchema = z
+    .object({
+    windowTimesteps: z
+        .number()
+        .int()
+        .positive()
+        .optional()
+        .describe("Decode window size in timesteps (addon default: 1500)."),
+    hopTimesteps: z
+        .number()
+        .int()
+        .positive()
+        .optional()
+        .describe("How far the window advances between decodes (addon default: 500). Must be < windowTimesteps."),
+    emit: z
+        .enum(["delta", "full"])
+        .optional()
+        .describe("'delta' (default) emits only the newly-discovered tail per window; 'full' emits the full running transcript each update."),
+})
+    .refine((opts) => opts.windowTimesteps === undefined ||
+    opts.hopTimesteps === undefined ||
+    opts.hopTimesteps < opts.windowTimesteps, {
+    message: "hopTimesteps must be < windowTimesteps",
+    path: ["hopTimesteps"],
+});
+export const bciTranscribeStreamRequestSchema = bciTranscribeBaseSchema.extend({
+    type: z.literal("bciTranscribeStream"),
+    streamOpts: bciStreamOptsSchema.optional(),
+    requestId: z
+        .string()
+        .min(1)
+        .optional()
+        .describe("Stable identifier for this in-flight duplex BCI transcription, generated by the client at call time. Surfaces on the registry so callers can target it with `cancel({ requestId })`. Optional on the wire — the server falls back to a server-generated id when the field is missing."),
+});
+export const bciTranscribeStreamResponseSchema = bciTranscriptionResultBase.extend({
+    type: z.literal("bciTranscribeStream"),
+});