@flamai/finesse 0.1.2 → 0.2.0

package/dist/index.d.ts

@@ -234,6 +234,151 @@ declare class CloneTimeoutError extends FinesseError {
     constructor(jobId: string, timeoutMs: number);
 }
 
+/** Response shapes. Field names match the API (snake_case); timestamps are Unix milliseconds.
+ * Media URLs (`original_audio_url`, `sample_audio_url`, `avatar_url`, `audio_url`) may be
+ * short-lived signed URLs: download them promptly, or fetch the object again for a fresh one. */
+interface VoiceSettings {
+    stability?: number;
+    similarity?: number;
+    style?: number;
+    speed?: number;
+    pitch?: number;
+    volume?: number;
+    use_speaker_boost?: boolean;
+    emotion?: string;
+    engine_params?: Record<string, unknown>;
+}
+/** A voice. It can synthesize once `status === "ready"`. */
+interface Voice {
+    id: string;
+    org_id: string;
+    name: string;
+    /** `draft`, `processing`, `ready`, `failed`, ... */
+    status: string;
+    clone_method: string;
+    /** `private` for your voices, `public` for platform catalog voices. */
+    visibility: string;
+    primary_language: string;
+    description?: string;
+    model?: string;
+    /** Human-friendly handle, also usable as `voice` on the OpenAI-compatible endpoint. */
+    alias?: string;
+    source?: string;
+    language?: string;
+    gender?: string;
+    /** Labels as a plain object (the API sends `[{key, value}]`; the SDK converts it). */
+    labels: Record<string, string>;
+    settings?: VoiceSettings;
+    external_ref?: string;
+    original_audio_url?: string;
+    sample_audio_url?: string;
+    avatar_url?: string;
+    base_voice_id?: string;
+    created_at?: number;
+    updated_at?: number;
+    last_used_at?: number;
+    expires_at?: number;
+    /** Prefix of the API key that created the voice; only on your own voices. */
+    created_via_key_prefix?: string;
+    [key: string]: unknown;
+}
+/** An asynchronous clone job. */
+interface CloneJob {
+    id: string;
+    org_id: string;
+    /** `pending`, `running`, `succeeded`, `failed`, `cancelled` or `expired`. */
+    status: string;
+    job_type: string;
+    voice_id?: string;
+    /** Percent complete. Not updated while running; 100 once succeeded. */
+    progress: number;
+    attempts: number;
+    /** Failure detail, `{message, status_code}`. */
+    error?: Record<string, unknown> | null;
+    started_at?: number;
+    finished_at?: number;
+    created_at?: number;
+    [key: string]: unknown;
+}
+/** What `voices.clone` / `voices.enroll` return: the voice (`processing`) and its job id. */
+interface CloneResult {
+    voice: Voice;
+    job_id: string;
+}
+/** A synthesized clip from `speech.create`. */
+interface Audio {
+    data: Uint8Array;
+    /** `audio/wav` for WAV, `application/octet-stream` for raw PCM. */
+    contentType: string;
+    sampleRate: number | null;
+    /** Id of the generation history record (when object storage is enabled). */
+    generationId: string | null;
+    /** The stored clip, when object storage is enabled; may be a short-lived signed URL. */
+    audioURL: string | null;
+    billingRemaining: number | null;
+}
+/** One chunk of raw PCM from `speech.stream`. */
+interface AudioChunk {
+    pcm: Uint8Array;
+    sampleRate: number | null;
+    /** PCM encoding, e.g. `s16le`. */
+    audioFormat: string | null;
+    index: number | null;
+}
+/** The final event of `speech.stream`. */
+interface StreamDone {
+    audio_duration_s?: number;
+    generation_id?: string;
+    audio_url?: string;
+}
+/** `wav` (one-shot default) or raw little-endian PCM. */
+/** A short-lived, single-use token from `tokens.create`. Hand `token` to a browser or device:
+ * it is good for one `speech.create` / `speech.stream` call or one realtime session, carries
+ * the `tts` scope only, and dies when the key that minted it is revoked or expires. */
+interface AccessToken {
+    token: string;
+    /** Unix epoch ms. */
+    expires_at: number;
+    ttl_seconds: number;
+}
+/** A direct realtime session from `realtime.sessions.create`: a socket straight to the
+ * synthesis GPU in your account's server region. Pass it to `realtime.connect({ session })`. */
+interface DirectSession {
+    session_id: string;
+    /** The GPU's WebSocket URL. Connect to it as returned. */
+    url: string;
+    /** The subprotocol to offer first (`finesse.v1`). */
+    protocol: string;
+    /** Single-use `ft1.` token, offered as the second subprotocol. */
+    token: string;
+    /** RFC 3339 time by which the socket must open (60 s after creation). */
+    connect_by: string;
+    /** The longest the session can run once connected. */
+    ttl_seconds: number;
+    /** Characters reserved for the session; it cannot synthesize more. */
+    budget_chars: number;
+    /** GPU region the session runs in: `ap-south` or `us-east`. */
+    region: string;
+    /** The only voices the session can use. */
+    voices: string[];
+}
+/** `mulaw` is raw G.711 µ-law for telephony and needs `sample_rate: 8000`. */
+type OutputFormat = "wav" | "s16le" | "s24le" | "s32le" | "f32le" | "f64le" | "mulaw";
+interface SpeechParams {
+    /** One of your voices or a public platform voice; it must be ready. */
+    voice_id: string;
+    /** At most 10,000 characters. Billed per character. */
+    text: string;
+    language?: string;
+    output_format?: OutputFormat;
+    /** Output rate in Hz, 8000-48000. The native rate is 24000; 8000 is produced as asked, other
+     * lower values still return 24000. */
+    sample_rate?: number;
+    /** Generation steps, 1-32 (default and maximum 32; over 32 is a 400); fewer is faster. */
+    num_step?: number;
+}
+declare const isReady: (voice: Voice) => boolean;
+
 /**
  * Realtime speech over one WebSocket. One session is one socket; each turn of speech runs in a
  * *context*, and a socket can run several contexts at once (up to 4). Audio arrives as raw PCM,
@@ -255,6 +400,11 @@ declare class CloneTimeoutError extends FinesseError {
  * in the WebSocket subprotocol list (`["finesse.v1", token]`), the one place a browser can put
  * a credential on a handshake. (With a key, browsers and Deno before 2.5 fall back to a
  * deprecated URL parameter, and the SDK logs a warning once.)
+ *
+ * For the lowest latency, run a *direct session*: the socket goes straight to the synthesis GPU
+ * in your account's server region instead of through the API. Create one on your server with
+ * `realtime.sessions.create` and connect with `{ session }` or `{ getSession }`. The messages
+ * and events are the same.
  */
 
 /** A realtime context or session failed. */
@@ -263,7 +413,8 @@ declare class RealtimeError extends FinesseError {
      * voices), `invalid_request` (a parameter out of range), a `task_failed` code. Whole session:
      * `insufficient_credits`, `upstream_unavailable` (the engine could not be reached),
      * `upstream_busy` (it is at capacity), `upstream_error`, `upstream_closed`,
-     * `connection_lost`, `token_spent`, ... */
+     * `connection_lost`, `token_spent`, `session_spent`, `session_expired`, `unauthorized` (a
+     * direct session's token was refused), ... */
     readonly code: string;
     /** The context it applies to, or `null` for the whole session. */
     readonly contextId: string | null;
@@ -358,9 +509,23 @@ interface ConnectOptions {
     /** Returns a fresh token, e.g. from your own backend running `tokens.create`. Used for the
      * first handshake when there is no `accessToken`, and for every reconnect. */
     getAccessToken?: () => string | Promise<string>;
+    /** A direct session from `realtime.sessions.create`, usually created by your server. Its token
+     * is single use, so pass `getSession` too if the session should reconnect. */
+    session?: DirectSession;
+    /** Returns a new direct session, e.g. `() => client.realtime.sessions.create({ voice_ids })`
+     * on a server, or a call to your own backend in a browser. Used for the first handshake when
+     * there is no `session`, and for every reconnect. */
+    getSession?: () => DirectSession | Promise<DirectSession>;
     /** A WebSocket implementation (defaults to the `ws` package in Node, the global elsewhere). */
     WebSocket?: unknown;
 }
+interface CreateDirectSessionParams {
+    /** The voices the session may use: 1 to 16 of your voices or public platform voices. */
+    voice_ids: string[];
+    /** Characters to reserve, 1-200000 (default 20000). Unused characters are returned when the
+     * session ends. If the balance can't cover it, 1000 are reserved instead. */
+    budget_chars?: number;
+}
 /**
  * One turn of speech. Create it with {@link RealtimeSession.context}. `send` text (the first
  * call opens the context), `finish` when the turn's text is complete, and iterate it for its
@@ -428,8 +593,15 @@ declare class RealtimeSession {
     private closedWaiters;
     private readonly staticToken;
     private tokenSpent;
+    private readonly directMode;
+    private staticSessionSpent;
+    private current;
     constructor(core: Core, options?: ConnectOptions);
+    /** Where the socket connects: the API's `/stream`, or a direct session's GPU URL. */
     get url(): string;
+    /** The direct session the socket runs on (its region and budget), or `null` when the session
+     * goes through the API. */
+    get directSession(): DirectSession | null;
     get isOpen(): boolean;
     /**
      * Open the socket (no-op when open). Throws `AuthenticationError`, `PaymentRequiredError` or
@@ -460,144 +632,52 @@ declare class RealtimeSession {
     /** The token for the next handshake, or `null` to use the API key. A static token is used
      * first; once a handshake has spent it, `getAccessToken` supplies one per reconnect. */
     private nextToken;
+    /** The direct session for the next handshake. Like a token, a static session is used first;
+     * once a handshake has spent it, `getSession` supplies one per reconnect. */
+    private nextSession;
     private dial;
     private onClose;
     private onAudio;
     private onMessage;
 }
+/** `client.realtime.sessions`: direct sessions, which run straight against the synthesis GPU. */
+declare class DirectSessions {
+    private readonly core;
+    constructor(core: Core);
+    /** Create a direct session. Call this on your server with an API key that has the `tts`
+     * scope; it reserves `budget_chars` from your balance now. Connect within 60 s
+     * (`connect_by`), with `realtime.connect({ session })`, or hand `url`, `protocol` and `token`
+     * to a browser:
+     *
+     * ```ts
+     * const session = await client.realtime.sessions.create({ voice_ids: [voiceId] });
+     * const rt = await client.realtime.connect({ session });
+     * ```
+     */
+    create(params: CreateDirectSessionParams, options?: RequestOptions): Promise<DirectSession>;
+}
 /** `client.realtime`: open realtime sessions. */
 declare class Realtime {
     private readonly core;
+    /** Direct sessions: lower latency, straight to the GPU. */
+    readonly sessions: DirectSessions;
     constructor(core: Core);
     /** Open a session. */
     connect(options?: ConnectOptions): Promise<RealtimeSession>;
     /** Create a session without opening it; it opens on first use. */
     session(options?: ConnectOptions): RealtimeSession;
 }
-
-/** Response shapes. Field names match the API (snake_case); timestamps are Unix milliseconds.
- * Media URLs (`original_audio_url`, `sample_audio_url`, `avatar_url`, `audio_url`) may be
- * short-lived signed URLs: download them promptly, or fetch the object again for a fresh one. */
-interface VoiceSettings {
-    stability?: number;
-    similarity?: number;
-    style?: number;
-    speed?: number;
-    pitch?: number;
-    volume?: number;
-    use_speaker_boost?: boolean;
-    emotion?: string;
-    engine_params?: Record<string, unknown>;
-}
-/** A voice. It can synthesize once `status === "ready"`. */
-interface Voice {
-    id: string;
-    org_id: string;
-    name: string;
-    /** `draft`, `processing`, `ready`, `failed`, ... */
-    status: string;
-    clone_method: string;
-    /** `private` for your voices, `public` for platform catalog voices. */
-    visibility: string;
-    primary_language: string;
-    description?: string;
-    model?: string;
-    /** Human-friendly handle, also usable as `voice` on the OpenAI-compatible endpoint. */
-    alias?: string;
-    source?: string;
-    language?: string;
-    gender?: string;
-    /** Labels as a plain object (the API sends `[{key, value}]`; the SDK converts it). */
-    labels: Record<string, string>;
-    settings?: VoiceSettings;
-    external_ref?: string;
-    original_audio_url?: string;
-    sample_audio_url?: string;
-    avatar_url?: string;
-    base_voice_id?: string;
-    created_at?: number;
-    updated_at?: number;
-    last_used_at?: number;
-    expires_at?: number;
-    /** Prefix of the API key that created the voice; only on your own voices. */
-    created_via_key_prefix?: string;
-    [key: string]: unknown;
-}
-/** An asynchronous clone job. */
-interface CloneJob {
-    id: string;
-    org_id: string;
-    /** `pending`, `running`, `succeeded`, `failed`, `cancelled` or `expired`. */
-    status: string;
-    job_type: string;
-    voice_id?: string;
-    /** Percent complete. Not updated while running; 100 once succeeded. */
-    progress: number;
-    attempts: number;
-    /** Failure detail, `{message, status_code}`. */
-    error?: Record<string, unknown> | null;
-    started_at?: number;
-    finished_at?: number;
-    created_at?: number;
-    [key: string]: unknown;
-}
-/** What `voices.clone` / `voices.enroll` return: the voice (`processing`) and its job id. */
-interface CloneResult {
-    voice: Voice;
-    job_id: string;
-}
-/** A synthesized clip from `speech.create`. */
-interface Audio {
-    data: Uint8Array;
-    /** `audio/wav` for WAV, `application/octet-stream` for raw PCM. */
-    contentType: string;
-    sampleRate: number | null;
-    /** Id of the generation history record (when object storage is enabled). */
-    generationId: string | null;
-    /** The stored clip, when object storage is enabled; may be a short-lived signed URL. */
-    audioURL: string | null;
-    billingRemaining: number | null;
-}
-/** One chunk of raw PCM from `speech.stream`. */
-interface AudioChunk {
-    pcm: Uint8Array;
-    sampleRate: number | null;
-    /** PCM encoding, e.g. `s16le`. */
-    audioFormat: string | null;
-    index: number | null;
-}
-/** The final event of `speech.stream`. */
-interface StreamDone {
-    audio_duration_s?: number;
-    generation_id?: string;
-    audio_url?: string;
-}
-/** `wav` (one-shot default) or raw little-endian PCM. */
-/** A short-lived, single-use token from `tokens.create`. Hand `token` to a browser or device:
- * it is good for one `speech.create` / `speech.stream` call or one realtime session, carries
- * the `tts` scope only, and dies when the key that minted it is revoked or expires. */
-interface AccessToken {
-    token: string;
-    /** Unix epoch ms. */
-    expires_at: number;
-    ttl_seconds: number;
-}
-/** `mulaw` is raw G.711 µ-law for telephony and needs `sample_rate: 8000`. */
-type OutputFormat = "wav" | "s16le" | "s24le" | "s32le" | "f32le" | "f64le" | "mulaw";
-interface SpeechParams {
-    /** One of your voices or a public platform voice; it must be ready. */
-    voice_id: string;
-    /** At most 10,000 characters. Billed per character. */
-    text: string;
-    language?: string;
-    output_format?: OutputFormat;
-    /** Output rate in Hz, 8000-48000. The native rate is 24000; 8000 is produced as asked, other
-     * lower values still return 24000. */
-    sample_rate?: number;
-    /** Generation steps, 1-32 (default and maximum 32; over 32 is a 400); fewer is faster. */
-    num_step?: number;
-}
-declare const isReady: (voice: Voice) => boolean;
+/**
+ * Open a direct session without a client, for a browser or device that holds no API key. Your
+ * server creates the session (`realtime.sessions.create`) and returns it; `getSession` fetches a
+ * new one for each reconnect.
+ *
+ * ```ts
+ * const getSession = async () => (await fetch("/api/finesse-session", { method: "POST" })).json();
+ * const rt = await connectDirect({ getSession });
+ * ```
+ */
+declare function connectDirect(options: Omit<ConnectOptions, "accessToken" | "getAccessToken">): Promise<RealtimeSession>;
 
 interface WaitOptions {
     /** Give up after this many ms. Default 300 000 (the first clone after the cloner has been
@@ -826,6 +906,6 @@ declare class Finesse {
     get withRawResponse(): RawClient<FinesseResources>;
 }
 
-declare const VERSION = "0.1.2";
+declare const VERSION = "0.2.0";
 
-export { APIConnectionError, APIStatusError, APITimeoutError, type AccessToken, type Audio, type AudioChunk, type AudioEvent, AuthenticationError, BadRequestError, type ClientOptions, CloneFailedError, type CloneJob, type CloneResult, CloneTimeoutError, type CloneVoiceParams, ConflictError, type ConnectOptions, type ConsentParams, type ContextOptions, type CreateTokenParams, type CreateVoiceParams, type EnrollVoiceParams, type FileInput, Finesse, FinesseError, InternalServerError, type ListVoicesParams, type LogLevel, type Logger, NotFoundError, type OutputFormat, PayloadTooLargeError, PaymentRequiredError, PermissionDeniedError, RateLimitError, type RawClient, type RawResponse, RealtimeContext, RealtimeError, type RealtimeEvent, RealtimeSession, type RequestOptions, type SentenceDone, type SpeechParams, SpeechStream, type StreamDone, StreamError, type TaskCancelled, type TaskDone, type TaskStarted, type UnknownEvent, UnprocessableEntityError, type UpdateVoiceParams, VERSION, type Voice, VoicePage, VoicePagePromise, type VoiceSettings, type WaitOptions, fileFromPath, isReady };
+export { APIConnectionError, APIStatusError, APITimeoutError, type AccessToken, type Audio, type AudioChunk, type AudioEvent, AuthenticationError, BadRequestError, type ClientOptions, CloneFailedError, type CloneJob, type CloneResult, CloneTimeoutError, type CloneVoiceParams, ConflictError, type ConnectOptions, type ConsentParams, type ContextOptions, type CreateDirectSessionParams, type CreateTokenParams, type CreateVoiceParams, type DirectSession, type EnrollVoiceParams, type FileInput, Finesse, FinesseError, InternalServerError, type ListVoicesParams, type LogLevel, type Logger, NotFoundError, type OutputFormat, PayloadTooLargeError, PaymentRequiredError, PermissionDeniedError, RateLimitError, type RawClient, type RawResponse, RealtimeContext, RealtimeError, type RealtimeEvent, RealtimeSession, type RequestOptions, type SentenceDone, type SpeechParams, SpeechStream, type StreamDone, StreamError, type TaskCancelled, type TaskDone, type TaskStarted, type UnknownEvent, UnprocessableEntityError, type UpdateVoiceParams, VERSION, type Voice, VoicePage, VoicePagePromise, type VoiceSettings, type WaitOptions, connectDirect, fileFromPath, isReady };

package/dist/index.js

@@ -163,7 +163,7 @@ function numberField(body2, key) {
 }
 
 // src/version.ts
-var VERSION = "0.1.2";
+var VERSION = "0.2.0";
 
 // src/core.ts
 var DEFAULT_BASE_URL = "https://fi.production.flamapis.com";
@@ -526,7 +526,8 @@ var RealtimeError = class extends FinesseError {
    * voices), `invalid_request` (a parameter out of range), a `task_failed` code. Whole session:
    * `insufficient_credits`, `upstream_unavailable` (the engine could not be reached),
    * `upstream_busy` (it is at capacity), `upstream_error`, `upstream_closed`,
-   * `connection_lost`, `token_spent`, ... */
+   * `connection_lost`, `token_spent`, `session_spent`, `session_expired`, `unauthorized` (a
+   * direct session's token was refused), ... */
   code;
   /** The context it applies to, or `null` for the whole session. */
   contextId;
@@ -543,8 +544,15 @@ var RealtimeError = class extends FinesseError {
     return RETRYABLE_CODES.has(this.code) || this.closeCode !== null && RETRYABLE_CLOSES.has(this.closeCode);
   }
 };
-function closeError(code, reason) {
+function closeError(code, reason, direct = false) {
   const c = { closeCode: code };
+  if (direct && code === 4401) {
+    return new RealtimeError(
+      "unauthorized",
+      "The session token was refused (invalid, already used, or past connect_by). Create a new session.",
+      c
+    );
+  }
   if (code === 1e3) return null;
   if (code === 1008) return new RealtimeError(reason || "policy_violation", reason, c);
   if (code === 1009) return new RealtimeError("message_too_big", "A message was too large.", c);
@@ -760,7 +768,13 @@ var RealtimeSession = class {
   constructor(core, options = {}) {
     this.core = core;
     this.options = options;
-    this.staticToken = options.accessToken ?? core.accessToken;
+    this.directMode = Boolean(options.session || options.getSession);
+    if (this.directMode && (options.accessToken || options.getAccessToken)) {
+      throw new FinesseError(
+        "Pass { session } / { getSession } or { accessToken } / { getAccessToken }, not both."
+      );
+    }
+    this.staticToken = this.directMode ? null : options.accessToken ?? core.accessToken;
   }
   core;
   options;
@@ -775,9 +789,19 @@ var RealtimeSession = class {
   closedWaiters = [];
   staticToken;
   tokenSpent = false;
+  directMode;
+  staticSessionSpent = false;
+  current = null;
+  /** Where the socket connects: the API's `/stream`, or a direct session's GPU URL. */
   get url() {
+    if (this.directMode) return this.current?.url ?? this.options.session?.url ?? "";
     return `${this.core.wsBaseURL}${API_PREFIX}/stream`;
   }
+  /** The direct session the socket runs on (its region and budget), or `null` when the session
+   * goes through the API. */
+  get directSession() {
+    return this.current;
+  }
   get isOpen() {
     return this.ws !== null && this.ws.readyState === OPEN;
   }
@@ -911,6 +935,31 @@ var RealtimeSession = class {
     }
     return null;
   }
+  /** The direct session for the next handshake. Like a token, a static session is used first;
+   * once a handshake has spent it, `getSession` supplies one per reconnect. */
+  async nextSession() {
+    const fixed = this.options.session;
+    if (fixed && !this.staticSessionSpent) {
+      if (Date.parse(fixed.connect_by) <= Date.now()) {
+        throw new RealtimeError(
+          "session_expired",
+          "This direct session's connect_by has passed. Create a new session."
+        );
+      }
+      return fixed;
+    }
+    if (this.options.getSession) {
+      const s = await this.options.getSession();
+      if (!s || typeof s.url !== "string" || !s.url || typeof s.token !== "string" || !s.token) {
+        throw new FinesseError("getSession must return a session with a url and a token.");
+      }
+      return s;
+    }
+    throw new RealtimeError(
+      "session_spent",
+      "This direct session was used by an earlier connection. Pass { getSession } so a reconnect can create a new one."
+    );
+  }
   async dial() {
     const timeout = this.options.openTimeout ?? DEFAULT_OPEN_TIMEOUT_MS;
     const custom = this.options.WebSocket;
@@ -918,11 +967,21 @@ var RealtimeSession = class {
       headers: !isBrowser(),
       open: (url2, h, t, protocols2) => h ? new custom(url2, protocols2, { headers: h, handshakeTimeout: t }) : new custom(url2, protocols2)
     } : await defaultDialer();
-    const token = await this.nextToken();
-    const protocols = token ? [SUBPROTOCOL, token] : void 0;
+    const direct = this.directMode ? await this.nextSession() : null;
+    const token = direct ? null : await this.nextToken();
+    let protocols = token ? [SUBPROTOCOL, token] : void 0;
     let url = this.url;
     let headers = null;
-    if (token) {
+    if (direct) {
+      protocols = [direct.protocol || SUBPROTOCOL, direct.token];
+      url = direct.url;
+      if (dialer.headers) {
+        headers = { ...this.core.headers };
+        delete headers.Accept;
+        delete headers["X-API-Key"];
+        delete headers.Authorization;
+      }
+    } else if (token) {
       if (dialer.headers) {
         headers = { ...this.core.headers };
         delete headers.Accept;
@@ -981,6 +1040,10 @@ var RealtimeSession = class {
       throw new RealtimeError("session_closed", "This session was closed.");
     }
     if (token && token === this.staticToken) this.tokenSpent = true;
+    if (direct) {
+      if (direct === this.options.session) this.staticSessionSpent = true;
+      this.current = direct;
+    }
     this.ws = ws;
     this.pendingAudio = null;
     this.fatal = null;
@@ -999,14 +1062,14 @@ var RealtimeSession = class {
   }
   onClose(ws, code, reason) {
     if (this.ws !== null && this.ws !== ws) {
-      const err = closeError(code, reason ?? "") ?? new RealtimeError("connection_closed");
+      const err = closeError(code, reason ?? "", this.directMode) ?? new RealtimeError("connection_closed");
       for (const ctx of [...this.contexts.values()]) if (ctx.socket === ws) ctx._fail(err);
       return;
     }
     this.ws = null;
     let error = this.fatal;
     if (error) error.closeCode ??= code;
-    else error = closeError(code, reason ?? "");
+    else error = closeError(code, reason ?? "", this.directMode);
     if (!error && this.contexts.size) {
       error = new RealtimeError("connection_closed", "The session ended.", { closeCode: code });
     }
@@ -1073,11 +1136,35 @@ var RealtimeSession = class {
     );
   }
 };
+var DirectSessions = class {
+  constructor(core) {
+    this.core = core;
+  }
+  core;
+  /** Create a direct session. Call this on your server with an API key that has the `tts`
+   * scope; it reserves `budget_chars` from your balance now. Connect within 60 s
+   * (`connect_by`), with `realtime.connect({ session })`, or hand `url`, `protocol` and `token`
+   * to a browser:
+   *
+   * ```ts
+   * const session = await client.realtime.sessions.create({ voice_ids: [voiceId] });
+   * const rt = await client.realtime.connect({ session });
+   * ```
+   */
+  async create(params, options = {}) {
+    const json = { voice_ids: params.voice_ids };
+    if (params.budget_chars !== void 0) json.budget_chars = params.budget_chars;
+    return this.core.json("POST", "/realtime/sessions", { ...options, json });
+  }
+};
 var Realtime = class {
   constructor(core) {
     this.core = core;
+    this.sessions = new DirectSessions(core);
   }
   core;
+  /** Direct sessions: lower latency, straight to the GPU. */
+  sessions;
   /** Open a session. */
   async connect(options = {}) {
     const session = new RealtimeSession(this.core, options);
@@ -1089,6 +1176,15 @@ var Realtime = class {
     return new RealtimeSession(this.core, options);
   }
 };
+async function connectDirect(options) {
+  if (!options.session && !options.getSession) {
+    throw new FinesseError("connectDirect needs { session } or { getSession }.");
+  }
+  const core = new Core({ accessToken: "direct-session-only" });
+  const session = new RealtimeSession(core, options);
+  await session.open();
+  return session;
+}
 var warnedLoggers = /* @__PURE__ */ new WeakSet();
 function warnQueryKey(logger) {
   if (warnedLoggers.has(logger)) return;
@@ -1716,6 +1812,7 @@ export {
   VERSION,
   VoicePage,
   VoicePagePromise,
+  connectDirect,
   fileFromPath,
   isReady
 };