@rimelabs/sdk 0.1.0-alpha.10 → 0.1.0-alpha.12

package/dist/stt/types.d.ts

@@ -0,0 +1,34 @@
+import type { PCMFormat } from "../pcm.js";
+/** Formatting intent, for example "flight 247" or "flight two four seven". */
+export type TranscriptionMode = "written" | "verbatim";
+/** One caller-ended utterance of headerless signed PCM16 little-endian audio. */
+export type AudioSource = AsyncIterable<Uint8Array>;
+export interface TranscriptionOptions {
+    /** Required BCP-47 tag, passed unchanged to the service (for example "en"). */
+    language: string;
+    /** Formatting intent; defaults to written and does not guarantee exact tokens. */
+    mode?: TranscriptionMode;
+    /** Recognition hints passed unchanged and in order, for example ["Super-G"]. */
+    contextTerms?: readonly string[];
+    /** Defaults to PCM16 little-endian mono 16 kHz; fixed for the utterance. */
+    inputFormat?: PCMFormat;
+    /** Optional overall deadline in seconds, including source and consumer pauses. */
+    timeout?: number | null;
+    /** Cancels only this utterance, including a pending connection. */
+    signal?: AbortSignal;
+}
+export interface TranscriptionPartial {
+    /** A revisable replacement snapshot. */
+    readonly kind: "partial";
+    /** Complete current text; replace previous text instead of appending it. */
+    readonly text: string;
+}
+export interface TranscriptionFinal {
+    /** Successful protocol and transport completion. */
+    readonly kind: "final";
+    /** Complete final text; silence can produce an empty string. */
+    readonly text: string;
+    /** Canonical BCP-47 tag selected by the service, for example "en". */
+    readonly language: string;
+}
+export type TranscriptionUpdate = TranscriptionPartial | TranscriptionFinal;

package/dist/stt/types.js

@@ -0,0 +1 @@
+export {};

package/dist/tts/client.d.ts

@@ -30,6 +30,9 @@ export declare class TTS {
     };
     constructor(credentials: Credentials, deployment: Readonly<typeof policy>, defaultTimeout: number | null, checkOpen: () => void);
     private prepare;
+    /** Synthesize complete text and return an audio stream. Do not await this call. */
+    synthesize(text: string, options?: SynthesisOptions): AudioStream;
+    /** Stream text chunks into synthesis and return an audio stream. Do not await this call. */
     stream(text: TextSource, options?: SynthesisOptions): AudioStream;
     private discover;
     close(): Promise<void>;

package/dist/tts/client.js

@@ -38,14 +38,24 @@ export class TTS {
         await connect(this.client, signal);
         return { client: this.client, metadata: metadata(auth) };
     }
+    /** Synthesize complete text and return an audio stream. Do not await this call. */
+    synthesize(text, options = {}) {
+        this.checkOpen();
+        if (typeof text !== "string")
+            throw new RimeInputError("text must be a string; use stream() for an async text source");
+        if (!text.trim())
+            throw new RimeInputError("Text must contain non-whitespace characters");
+        return this.stream((async function* () {
+            yield text;
+        })(), options);
+    }
+    /** Stream text chunks into synthesis and return an audio stream. Do not await this call. */
     stream(text, options = {}) {
         this.checkOpen();
-        if (typeof text === "string") {
-            if (!text.trim())
-                throw new RimeInputError("Text must contain non-whitespace characters");
-        }
-        else if (!text || typeof text[Symbol.asyncIterator] !== "function")
-            throw new RimeInputError("text must be a string or an async iterable of strings");
+        if (typeof text === "string" ||
+            !text ||
+            typeof text[Symbol.asyncIterator] !== "function")
+            throw new RimeInputError("text must be an async iterable of strings; use synthesize() for a string");
         const voice = options.voice === undefined || options.voice === null
             ? this.deployment.defaultVoice
             : nonempty(options.voice, "voice");

package/dist/tts/policy.d.ts

@@ -1,3 +1,4 @@
+export { timeout } from "../validation.js";
 export declare const policy: {
     target: string;
     audience: string;
@@ -16,5 +17,4 @@ export declare const policy: {
     cleanupTimeout: number;
 };
 export declare function resolve(model: string, endpoint?: string | null): Readonly<typeof policy>;
-export declare function timeout(value: unknown, inherited?: number | null): number | null;
 export declare function nonempty(value: unknown, name: string): string;

package/dist/tts/policy.js

@@ -1,3 +1,5 @@
+import { endpointAddress } from "../validation.js";
+export { timeout } from "../validation.js";
 import { RimeInputError } from "../errors.js";
 const codaHostname = "coda.api.rime.ai";
 export const policy = {
@@ -30,32 +32,7 @@ export function resolve(model, endpoint) {
     }
     if (endpoint === undefined || endpoint === null)
         return deployment;
-    const error = "endpoint must be a hostname with an optional port (1-65535), without a scheme or path";
-    if (typeof endpoint !== "string" || /\s/.test(endpoint))
-        throw new RimeInputError(error);
-    const [host, port, extra] = endpoint.split(":");
-    if (!host ||
-        host.length > 253 ||
-        extra !== undefined ||
-        host
-            .split(".")
-            .some((label) => !/^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/i.test(label)) ||
-        (port !== undefined &&
-            (!/^[0-9]{1,5}$/.test(port) || Number(port) < 1 || Number(port) > 65535)))
-        throw new RimeInputError(error);
-    return {
-        ...deployment,
-        target: `${host.toLowerCase()}:${port === undefined ? 443 : Number(port)}`,
-        audience: host.toLowerCase(),
-    };
-}
-export function timeout(value, inherited = null) {
-    if (value === undefined)
-        return inherited;
-    if (value !== null &&
-        (typeof value !== "number" || !Number.isFinite(value) || value <= 0))
-        throw new RimeInputError("timeout must be finite positive seconds or null");
-    return value;
+    return { ...deployment, ...endpointAddress(endpoint) };
 }
 export function nonempty(value, name) {
     if (typeof value !== "string" || !value.trim())

package/dist/tts/stream.d.ts

@@ -5,7 +5,7 @@ export interface StreamOwner {
     checkOpen(): void;
     forget(stream: AudioStream): void;
 }
-export type TextSource = string | AsyncIterable<string>;
+export type TextSource = AsyncIterable<string>;
 export declare const constructionKey: unique symbol;
 export declare class AudioStream implements AsyncIterableIterator<Uint8Array> {
     private owner;

package/dist/tts/stream.js

@@ -41,7 +41,7 @@ export class AudioStream {
         this.formatValue = formatValue;
         this.timeout = timeout;
         if (key !== constructionKey)
-            throw new TypeError("AudioStream is returned by client.tts.stream()");
+            throw new TypeError("AudioStream is returned by client.tts.synthesize() or client.tts.stream()");
     }
     get format() {
         return this.formatValue;
@@ -100,11 +100,7 @@ export class AudioStream {
         let meaningful = false;
         try {
             try {
-                iterator = (typeof source === "string"
-                    ? (async function* () {
-                        yield source;
-                    })()
-                    : source)[Symbol.asyncIterator]();
+                iterator = source[Symbol.asyncIterator]();
             }
             catch (error) {
                 if (this.controller.signal.aborted)

package/dist/tts/transport.d.ts

@@ -1,31 +1,23 @@
+export { metadata } from "../grpc.js";
+export { rpcError } from "../grpc.js";
 import * as grpc from "@grpc/grpc-js";
-import * as errors from "../errors.js";
 export type Connection = grpc.Client;
 export interface PreparedConnection {
     client: Connection;
     metadata: grpc.Metadata;
 }
 export type DiscoveryKind = "voices" | "languages";
-export declare function rpcError(code: number, requestId?: string | null): errors.RimeError;
 export declare const transport: {
     makeClient: (target: string) => grpc.Client;
 };
 export declare function connect(client: grpc.Client, signal: AbortSignal): Promise<void>;
-export declare function metadata(value: string): grpc.Metadata;
 export declare function discover(prepared: PreparedConnection, kind: DiscoveryKind, language: string | null | undefined, signal: AbortSignal): Promise<string[]>;
 export declare class SynthesisCall {
-    private signal;
-    private readonly call;
-    private readonly metadataPromise;
-    private readonly statusPromise;
-    private status;
-    private id;
+    private readonly rpc;
     constructor(prepared: PreparedConnection, signal: AbortSignal);
     get requestId(): string | null;
     get done(): boolean;
     cancel(): void;
-    private error;
-    private writeMessage;
     start(voice: string, language: string): Promise<void>;
     write(sentence: string): Promise<void>;
     finishInput(): void;

package/dist/tts/transport.js

@@ -1,22 +1,13 @@
+import { connect as connectGrpc } from "../grpc.js";
+export { metadata } from "../grpc.js";
+import { BidiCall, serializer, deserializer, requestId, nativeError, } from "../grpc.js";
+export { rpcError } from "../grpc.js";
 import * as grpc from "@grpc/grpc-js";
-import { create, fromBinary, toBinary, } from "@bufbuild/protobuf";
+import { create, } from "@bufbuild/protobuf";
 import * as schema from "@rimelabs/api";
 import { policy } from "./policy.js";
 import { abortable } from "../cancellation.js";
 import * as errors from "../errors.js";
-export function rpcError(code, requestId = null) {
-    const classes = {
-        [grpc.status.UNAUTHENTICATED]: errors.RimeAuthenticationError,
-        [grpc.status.PERMISSION_DENIED]: errors.RimePermissionError,
-        [grpc.status.INVALID_ARGUMENT]: errors.RimeInputError,
-        [grpc.status.RESOURCE_EXHAUSTED]: errors.RimeResourceLimitError,
-        [grpc.status.UNAVAILABLE]: errors.RimeUnavailableError,
-        [grpc.status.DEADLINE_EXCEEDED]: errors.RimeTimeoutError,
-        [grpc.status.CANCELLED]: errors.RimeCancelledError,
-    };
-    const ErrorType = classes[code] ?? errors.RimeStreamError;
-    return new ErrorType(`Rime operation failed: ${grpc.status[code] ?? "UNKNOWN"}`, requestId);
-}
 export const transport = {
     makeClient: (target) => new grpc.Client(target, grpc.credentials.createSsl(), {
         "grpc.enable_retries": 0,
@@ -24,21 +15,8 @@ export const transport = {
         "grpc.max_send_message_length": policy.sentenceBytes + 65536,
     }),
 };
-function serializer(desc) {
-    return (message) => Buffer.from(toBinary(desc, message));
-}
-function deserializer(desc) {
-    return (data) => fromBinary(desc, data);
-}
-export async function connect(client, signal) {
-    await abortable(new Promise((resolve, reject) => client.waitForReady(Date.now() + policy.connectionTimeout * 1000, (error) => error
-        ? reject(new errors.RimeTimeoutError("Connection establishment timed out"))
-        : resolve())), signal);
-}
-export function metadata(value) {
-    const result = new grpc.Metadata();
-    result.set("authorization", value);
-    return result;
+export function connect(client, signal) {
+    return connectGrpc(client, signal, policy.connectionTimeout);
 }
 function openStream(client, auth) {
     return client.makeBidiStreamRequest("/rime.TextToSpeech/SynthesizeStreaming", serializer(schema.StreamingSynthesisRequestSchema), deserializer(schema.SynthesisResponseStreamSchema), auth);
@@ -60,23 +38,6 @@ function textMessage(text) {
         payload: { case: "textChunk", value: text },
     });
 }
-function requestId(metadata) {
-    return metadata?.get("x-request-id")[0]?.toString() ?? null;
-}
-function nativeError(error, id) {
-    if (error instanceof errors.RimeError)
-        return error;
-    if (error &&
-        typeof error === "object" &&
-        "code" in error &&
-        typeof error.code === "number") {
-        const metadata = "metadata" in error ? error.metadata : null;
-        return rpcError(error.code, id ?? (metadata instanceof grpc.Metadata ? requestId(metadata) : null));
-    }
-    return new errors.RimeStreamError("Rime transport failed", id, {
-        cause: error,
-    });
-}
 async function unary(prepared, name, input, output, request, signal) {
     let call;
     let id = null;
@@ -114,115 +75,42 @@ export async function discover(prepared, kind, language, signal) {
     return response.languages;
 }
 export class SynthesisCall {
-    signal;
-    call;
-    metadataPromise;
-    statusPromise;
-    status = null;
-    id = null;
+    rpc;
     constructor(prepared, signal) {
-        this.signal = signal;
-        this.call = openStream(prepared.client, prepared.metadata);
-        this.metadataPromise = new Promise((resolve, reject) => {
-            this.call.once("metadata", (metadata) => {
-                this.id = requestId(metadata);
-                resolve(metadata);
-            });
-            // A trailers-only response has no metadata event.
-            this.call.once("status", () => resolve(new grpc.Metadata()));
-            this.call.once("error", reject);
-        });
-        this.metadataPromise.catch(() => { });
-        this.statusPromise = new Promise((resolve) => {
-            this.call.once("status", (status) => {
-                this.status = status;
-                this.id ??= requestId(status.metadata);
-                resolve(status);
-            });
-        });
-        this.call.on("error", () => { });
+        this.rpc = new BidiCall(openStream(prepared.client, prepared.metadata), signal);
     }
     get requestId() {
-        return this.id;
+        return this.rpc.requestId;
     }
     get done() {
-        return this.status !== null || this.call.destroyed;
+        return this.rpc.done;
     }
     cancel() {
-        this.call.cancel();
-    }
-    error(error) {
-        const failure = nativeError(error, this.id);
-        this.id ??= failure.requestId;
-        return failure;
+        this.rpc.cancel();
     }
-    async writeMessage(message) {
-        try {
-            this.signal.throwIfAborted();
-            if (this.status) {
-                if (this.status.code !== grpc.status.OK)
-                    throw rpcError(this.status.code, this.id);
-                throw new errors.RimeStreamError("The service completed before input finished", this.id);
-            }
-            await abortable(new Promise((resolve, reject) => {
-                this.call.write(message, (error) => error ? reject(error) : resolve());
-            }), this.signal);
-        }
-        catch (error) {
-            if (this.signal.aborted)
-                throw this.signal.reason;
-            if (error instanceof errors.RimeError)
-                throw error;
-            // A native write error can precede the final status event. Preserve the
-            // server rejection even if the reader has not consumed a response.
-            const status = await abortable(this.statusPromise, this.signal);
-            if (status.code !== grpc.status.OK)
-                throw rpcError(status.code, this.id);
-            throw this.error(error);
-        }
+    start(voice, language) {
+        return this.rpc.write(header(voice, language));
     }
-    async start(voice, language) {
-        // Writes do not depend on response metadata.
-        await this.writeMessage(header(voice, language));
-    }
-    async write(sentence) {
-        await this.writeMessage(textMessage(sentence));
+    write(sentence) {
+        return this.rpc.write(textMessage(sentence));
     }
     finishInput() {
-        try {
-            this.call.end();
-        }
-        catch (error) {
-            throw this.error(error);
-        }
+        this.rpc.finishInput();
     }
     checkFormat(contentType) {
         if (contentType !== "audio/pcm")
-            throw new errors.RimeAudioFormatError("Expected raw audio/pcm from the service", this.id);
+            throw new errors.RimeAudioFormatError("Expected raw audio/pcm from the service", this.requestId);
     }
     async *audio() {
-        try {
-            const metadata = await abortable(this.metadataPromise, this.signal);
-            const contentType = metadata.get("x-rime-audio-content-type")[0];
-            const responses = this.call;
-            for await (const response of responses) {
-                if (response.payload.case !== "audio")
-                    continue;
-                const audio = response.payload.value;
-                if (audio.length)
-                    this.checkFormat(contentType);
-                yield audio;
-            }
-            const status = await abortable(this.statusPromise, this.signal);
-            if (status.code !== grpc.status.OK)
-                throw rpcError(status.code, this.id);
-            // Validate empty success only after giving a rejection its proper error.
-            this.checkFormat(contentType);
-        }
-        catch (error) {
-            if (this.signal.aborted)
-                throw this.signal.reason;
-            throw this.error(error);
+        const headers = await this.rpc.headers();
+        const contentType = headers.get("x-rime-audio-content-type")[0];
+        for await (const response of this.rpc.responses()) {
+            if (response.payload.case !== "audio")
+                continue;
+            if (response.payload.value.length)
+                this.checkFormat(contentType);
+            yield response.payload.value;
         }
+        this.checkFormat(contentType);
     }
 }

package/dist/validation.d.ts

@@ -0,0 +1,5 @@
+export declare function endpointAddress(endpoint: string): {
+    target: string;
+    audience: string;
+};
+export declare function timeout(value: unknown, inherited?: number | null): number | null;

package/dist/validation.js

@@ -0,0 +1,28 @@
+import { RimeInputError } from "./errors.js";
+export function endpointAddress(endpoint) {
+    const error = "endpoint must be a hostname with an optional port (1-65535), without a scheme or path";
+    if (typeof endpoint !== "string" || /\s/.test(endpoint))
+        throw new RimeInputError(error);
+    const [host, port, extra] = endpoint.split(":");
+    if (!host ||
+        host.length > 253 ||
+        extra !== undefined ||
+        host
+            .split(".")
+            .some((label) => !/^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/i.test(label)) ||
+        (port !== undefined &&
+            (!/^[0-9]{1,5}$/.test(port) || Number(port) < 1 || Number(port) > 65535)))
+        throw new RimeInputError(error);
+    return {
+        target: `${host.toLowerCase()}:${port === undefined ? 443 : Number(port)}`,
+        audience: host.toLowerCase(),
+    };
+}
+export function timeout(value, inherited = null) {
+    if (value === undefined)
+        return inherited;
+    if (value !== null &&
+        (typeof value !== "number" || !Number.isFinite(value) || value <= 0))
+        throw new RimeInputError("timeout must be finite positive seconds or null");
+    return value;
+}

package/docs/stt.md

@@ -0,0 +1,103 @@
+# Streaming speech recognition
+
+`client.stt.stream` transcribes one utterance from an async source of `Uint8Array` chunks (including Node buffers).
+The SDK handles the gRPC protocol, authentication, audio conversion, transcript
+revisions, backpressure, and cancellation. Your application decides when speech
+ends by exhausting the source.
+
+```typescript
+import { createReadStream } from "node:fs";
+import { Rime } from "@rimelabs/sdk";
+
+async function* audioChunks() {
+  yield* createReadStream("utterance.pcm");
+}
+
+const client = new Rime();
+try {
+  const transcript = client.stt.stream(audioChunks(), {
+    language: "en",
+    inputFormat: { sampleRate: 16000, channels: 1 },
+    mode: "written",
+    contextTerms: ["Super-G", "USOC"],
+    timeout: 120,
+  });
+  for await (const update of transcript) {
+    if (update.kind === "partial") console.log("Current transcript:", update.text);
+    else console.log("Final:", update.text, "Language:", update.language);
+  }
+  console.log("Request:", transcript.requestId);
+} finally {
+  await client.close();
+}
+```
+
+The runnable [example](../examples/stt/stream.mjs) reads a PCM file
+without loading it all into memory. Use Node.js 22 or later; browsers are not supported.
+Open files inside the async generator so file errors are reported through the
+SDK and resources are opened only after the service accepts the utterance.
+
+## Options
+
+| Option | Meaning |
+| --- | --- |
+| `language` | Required spoken BCP-47 tag. Passed unchanged to the service; no detection or SDK language allowlist. The deployed catalog currently supports English and Spanish. |
+| `mode` | `"written"` (default) or `"verbatim"`. Formatting intent, not a guarantee of exact tokens. |
+| `contextTerms` | Sequence of recognition hints, copied unchanged and in order. The service validates terms and prompt budgets. |
+| `inputFormat` | `PCMFormat`: signed little-endian PCM16 at 8, 16, 24 or 48 kHz, mono or interleaved stereo. Defaults to 16 kHz mono. |
+| `timeout` | Optional positive overall timeout in seconds. Includes connection time, source pauses and consumer pauses. `null` disables this SDK deadline, but not internal or server deadlines. |
+
+Input contains raw samples, with no WAV header or compressed codec. Chunks may
+split sample frames; the SDK carries incomplete bytes into the next chunk. A
+truncated final frame raises `RimeAudioFormatError`, without committing the
+utterance. Each gRPC audio payload is at most 64 KiB of 16 kHz mono PCM16.
+
+The default recognition endpoint is `stt.api.rime.ai:443`, using TLS and the same
+API key as the other features. `new Rime({ sttEndpoint: "host:443" })` overrides only STT.
+The existing `model`, `endpoint` and client `timeout` settings remain TTS settings.
+There is no STT voice/model selector; the service selects its recognizer.
+
+## Results and completion
+
+`TranscriptionPartial` and `TranscriptionFinal` are discriminated TypeScript types, exported from `@rimelabs/sdk`. Every update contains the complete current `text`.
+**Replace the previous transcript. Do not concatenate partials.** Later partials
+can change earlier words. `TranscriptionFinal.language` is the canonical language
+selected by the service.
+
+The source is not consumed until the server accepts the configuration. Audio
+upload and transcript reading run concurrently. Decoding currently uses cumulative
+two-second audio windows, so a partial is not promised for each audio packet.
+Silence can finish successfully with empty final text and no partials.
+
+Exhausting the source half-closes gRPC input. The SDK continues reading and emits
+one final result only after a matching `done` and successful gRPC completion.
+EOF, an error status, or cancellation cannot turn a partial into a final result.
+No audio is automatically replayed after a connection failure.
+
+## Lifetime and limits
+
+Construction is lazy: starting iteration begins work. Consume each stream with
+one reader. Breaking a `for await` loop calls the iterator's `return` and cancels
+unfinished work. `await transcript.cancel()` and async disposal also cancel it.
+Pass an `AbortSignal` through the stream's `signal` option to cancel just that
+utterance. Client close cancels all STT, TTS and realtime operations; cancelling
+one stream leaves its siblings running.
+
+The SDK bounds the transcript queue to 16 updates, each with at most 64 KiB of
+UTF-8 text, and bounds gRPC responses to 256 KiB. Slow consumers apply backpressure.
+Internal connection and acceptance waits are 10 seconds; completion after source
+exhaustion is bounded to 120 seconds. The completion timer stops after successful
+gRPC completion. The optional overall timeout remains active until the final
+result is consumed. An outstanding source `next()` cannot be forcibly stopped by
+JavaScript; the SDK stops waiting for it and attempts `return()` for at most two
+seconds. Sources that own devices should support cancellation themselves.
+
+Server input-idle, utterance-size, request-duration and model-context limits still
+apply. The current wire limit is 16 MiB per utterance; model context can impose a
+smaller limit depending on audio and recognition terms. There is no SDK VAD,
+server endpointing, word timing, diarization, or file-format detection.
+
+Failures use the shared SDK error hierarchy: caller/input errors, cancellation,
+authentication, permission, resource limits, timeouts, transient availability and
+protocol failures stay distinct. `requestId` is retained on streams and failures
+when the server supplies it. Keep it when reporting a problem.

package/docs/tts.md

@@ -4,9 +4,16 @@ You supply text; the SDK handles sentence boundaries and streams audio back.
 Your application owns playback. Start with the complete WAV example in the
 [package quick start](../README.md#tts-save-speech).
 
+## Complete text
+
+Use `client.tts.synthesize(text)` for one nonblank string. It returns an audio
+stream; it does not wait for all audio to be generated. Do not await this call.
+Use the audio loop and cleanup shown in the package quick start.
+
 ## Stream incoming text
 
-An async text source can supply text as it arrives:
+Use `client.tts.stream(chunks)` for an async iterable of strings. A plain string
+belongs in `synthesize`, not `stream`. The source can supply partial sentences:
 
 ```javascript
 async function* text() {
@@ -45,8 +52,8 @@ Model defaults still apply.
 
 ### Synthesis options
 
-The `text` argument is required and accepts a nonblank string or an async text
-source. All options in `client.tts.stream(text, { ... })` are optional:
+Both methods require text input: a nonblank string for `synthesize`, or an
+async iterable of strings for `stream`. Both accept the following optional settings:
 
 | Option | Default | Meaning |
 | --- | --- | --- |
@@ -97,7 +104,7 @@ import { Rime, RimeError } from "@rimelabs/sdk";
 let client;
 try {
   client = new Rime();
-  await writeFile("speech.pcm", client.tts.stream("Hello. This is Rime."));
+  await writeFile("speech.pcm", client.tts.synthesize("Hello. This is Rime."));
 } catch (error) {
   if (error instanceof RimeError) {
     console.error(`Speech failed: ${error.message}; requestId=${error.requestId}`);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@rimelabs/sdk",
-  "version": "0.1.0-alpha.10",
-  "description": "Rime streaming TTS and Prism realtime SDK for Node.js",
+  "version": "0.1.0-alpha.12",
+  "description": "Rime streaming TTS, STT and Prism realtime SDK for Node.js",
   "license": "MIT",
   "type": "module",
   "engines": {
@@ -29,12 +29,12 @@
     "check": "tsc -p tsconfig.json --noEmit",
     "test": "npm run build && node --test tests/*.test.mjs",
     "prepack": "npm run build",
-    "lint": "prettier --check src tests ../examples/typescript/tts ../examples/typescript/realtime ../examples/typescript/common ../examples/typescript/browser ../examples/typescript/tests"
+    "lint": "prettier --check src tests examples/tts examples/realtime examples/common examples/browser examples/tests examples/stt"
   },
   "dependencies": {
     "@bufbuild/protobuf": "^2.11.0",
     "@grpc/grpc-js": "^1.14.0",
-    "@rimelabs/api": "0.3.0",
+    "@rimelabs/api": "0.4.0",
     "ws": "^8.22.0"
   },
   "devDependencies": {