phonic 0.31.9 → 0.31.11

package/dist/cjs/custom/ReconnectableConversationsSocket.js

@@ -0,0 +1,283 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReconnectableConversationsSocket = void 0;
+const core = __importStar(require("../core/index.js"));
+const Socket_js_1 = require("../api/resources/conversations/client/Socket.js");
+const json_js_1 = require("../core/json.js");
+/** 1006 is the only close code that indicates an unexpected disconnect
+ *  worth reconnecting for. All other codes (1000, 4000, 4800, etc.)
+ *  are intentional server-side closes. */
+const ABNORMAL_CLOSURE = 1006;
+const BASE_RECONNECT_DELAY_MS = 500;
+const MAX_RECONNECT_DELAY_MS = 5000;
+/** Safety cap: stop retrying if the server is completely unreachable.
+ *  In normal operation the server's terminal codes (4800/4801) stop
+ *  retries much sooner (within the 10s grace period). */
+const MAX_RECONNECT_ATTEMPTS = 10;
+/**
+ * Wraps ConversationsSocket with automatic reconnection on 1006.
+ *
+ * On abnormal closure, creates a brand new ReconnectingWebSocket (via the
+ * createReconnectSocket factory) and wraps it in a fresh ConversationsSocket,
+ * forwarding all events to user-registered handlers.
+ *
+ * Retries reconnection with exponential backoff until the server responds
+ * with a terminal close code (4800 session expired, 4801 invalid state),
+ * the safety cap is reached, or the user calls close().
+ *
+ * Uses composition rather than inheritance to avoid coupling to the parent's
+ * private event handler registration or ReconnectingWebSocket internals.
+ */
+class ReconnectableConversationsSocket {
+    constructor(args) {
+        this._conversationId = null;
+        this._handlers = {};
+        this._reconnectAttempts = 0;
+        this._isClosed = false;
+        this._cleanupWireListeners = null;
+        this._pendingReconnect = null;
+        this._pendingReplacement = false;
+        this._createReconnectSocket = args.createReconnectSocket;
+        this._abortSignal = args.abortSignal != undefined ? args.abortSignal : null;
+        this._inner = new Socket_js_1.ConversationsSocket({ socket: args.socket });
+        this._wireInner(this._inner, args.socket);
+    }
+    /** The conversation ID captured from the server's conversation_created message. */
+    get conversationId() {
+        return this._conversationId;
+    }
+    get socket() {
+        return this._inner.socket;
+    }
+    get readyState() {
+        return this._inner.readyState;
+    }
+    on(event, callback) {
+        this._handlers[event] = callback;
+    }
+    /** Drop outbound sends when we cannot talk to a live socket (no queue). */
+    _safeSend(op) {
+        if (this._isClosed || this._pendingReplacement) {
+            return;
+        }
+        if (this._inner.readyState !== core.ReconnectingWebSocket.ReadyState.OPEN) {
+            return;
+        }
+        op(this._inner);
+    }
+    sendConfig(message) {
+        this._safeSend((inner) => inner.sendConfig(message));
+    }
+    sendAudioChunk(message) {
+        this._safeSend((inner) => inner.sendAudioChunk(message));
+    }
+    sendToolCallOutput(message) {
+        this._safeSend((inner) => inner.sendToolCallOutput(message));
+    }
+    sendUpdateSystemPrompt(message) {
+        this._safeSend((inner) => inner.sendUpdateSystemPrompt(message));
+    }
+    sendAddSystemMessage(message) {
+        this._safeSend((inner) => inner.sendAddSystemMessage(message));
+    }
+    sendSetExternalId(message) {
+        this._safeSend((inner) => inner.sendSetExternalId(message));
+    }
+    sendGenerateReply(message) {
+        this._safeSend((inner) => inner.sendGenerateReply(message));
+    }
+    sendSay(message) {
+        this._safeSend((inner) => inner.sendSay(message));
+    }
+    sendReset(message) {
+        this._safeSend((inner) => inner.sendReset(message));
+    }
+    /**
+     * Not supported — reconnection after 1006 is handled automatically.
+     * To start a new conversation, create a new socket via client.conversations.connect().
+     */
+    connect() {
+        throw new Error("connect() is not supported on ReconnectableConversationsSocket. "
+            + "Reconnection after 1006 is automatic. To start a new conversation, "
+            + "call client.conversations.connect() again.");
+    }
+    close() {
+        var _a;
+        this._isClosed = true;
+        this._pendingReplacement = false;
+        if (this._pendingReconnect != null) {
+            clearTimeout(this._pendingReconnect);
+            this._pendingReconnect = null;
+        }
+        (_a = this._cleanupWireListeners) === null || _a === void 0 ? void 0 : _a.call(this);
+        this._cleanupWireListeners = null;
+        this._inner.close();
+    }
+    waitForOpen() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._inner.waitForOpen();
+        });
+    }
+    _getReconnectDelay() {
+        // Exponential backoff: 500ms, 1s, 2s, 4s, capped at 5s
+        const delay = BASE_RECONNECT_DELAY_MS * Math.pow(2, this._reconnectAttempts - 1);
+        return Math.min(delay, MAX_RECONNECT_DELAY_MS);
+    }
+    /** Schedule a reconnection attempt after backoff delay. */
+    _scheduleReconnect() {
+        var _a, _b, _c;
+        if (this._isClosed || this._conversationId === null || ((_a = this._abortSignal) === null || _a === void 0 ? void 0 : _a.aborted)) {
+            return;
+        }
+        if (this._reconnectAttempts >= MAX_RECONNECT_ATTEMPTS) {
+            this._pendingReplacement = false;
+            (_c = (_b = this._handlers).error) === null || _c === void 0 ? void 0 : _c.call(_b, new Error("Max reconnect attempts reached"));
+            return;
+        }
+        // Clear any existing timer to prevent orphaned timeouts
+        if (this._pendingReconnect != null) {
+            clearTimeout(this._pendingReconnect);
+        }
+        this._reconnectAttempts++;
+        const delay = this._getReconnectDelay();
+        this._pendingReplacement = true;
+        this._pendingReconnect = setTimeout(() => {
+            this._pendingReconnect = null;
+            if (this._isClosed) {
+                this._pendingReplacement = false;
+                return;
+            }
+            void this._doReconnect();
+        }, delay);
+    }
+    /** Perform the actual reconnection attempt. */
+    _doReconnect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            try {
+                const created = this._createReconnectSocket(this._conversationId);
+                const newRawSocket = created instanceof Promise ? yield created : created;
+                if (this._isClosed || ((_a = this._abortSignal) === null || _a === void 0 ? void 0 : _a.aborted)) {
+                    this._pendingReplacement = false;
+                    newRawSocket.close();
+                    return;
+                }
+                // Clean up the old socket: remove our custom listeners and close
+                // the ConversationsSocket wrapper (which removes its own listeners).
+                (_b = this._cleanupWireListeners) === null || _b === void 0 ? void 0 : _b.call(this);
+                this._cleanupWireListeners = null;
+                try {
+                    this._inner.close();
+                }
+                catch ( /* already closed from 1006 */_c) { /* already closed from 1006 */ }
+                const newInner = new Socket_js_1.ConversationsSocket({ socket: newRawSocket });
+                this._inner = newInner;
+                this._wireInner(newInner, newRawSocket);
+            }
+            catch (_d) {
+                this._pendingReplacement = false;
+                // Connection failed — schedule another attempt.
+                // The server's grace period (10s) is the natural limit;
+                // once it expires, the next attempt will get 4800 and stop.
+                this._scheduleReconnect();
+            }
+        });
+    }
+    _wireInner(inner, rawSocket) {
+        // Forward events from the inner ConversationsSocket to user handlers.
+        // Clear _pendingReplacement before calling the user's open handler
+        // so that sends inside the handler are not silently dropped.
+        inner.on("open", () => {
+            var _a, _b;
+            this._pendingReplacement = false;
+            (_b = (_a = this._handlers).open) === null || _b === void 0 ? void 0 : _b.call(_a);
+        });
+        inner.on("message", (msg) => { var _a, _b; return (_b = (_a = this._handlers).message) === null || _b === void 0 ? void 0 : _b.call(_a, msg); });
+        inner.on("close", (ev) => { var _a, _b; return (_b = (_a = this._handlers).close) === null || _b === void 0 ? void 0 : _b.call(_a, ev); });
+        inner.on("error", (err) => { var _a, _b; return (_b = (_a = this._handlers).error) === null || _b === void 0 ? void 0 : _b.call(_a, err); });
+        // Intercept raw messages to capture conversation_id and reset reconnect counter
+        const onMessage = (event) => {
+            try {
+                const data = (0, json_js_1.fromJson)(event.data);
+                if (data && typeof data === "object" && "type" in data) {
+                    const type = data.type;
+                    if (type === "conversation_created") {
+                        this._conversationId = data.conversation_id;
+                    }
+                    if (type === "conversation_reconnected") {
+                        this._reconnectAttempts = 0;
+                    }
+                }
+            }
+            catch (_a) {
+                // ignore — inner socket handles parse errors
+            }
+        };
+        const onClose = (event) => {
+            if (this._isClosed) {
+                return;
+            }
+            if (event.code === ABNORMAL_CLOSURE && this._conversationId !== null) {
+                // We have a conversation to resume — cancel RWS's built-in
+                // auto-reconnect and handle it ourselves with reconnect_conv_id.
+                // _handleClose calls _connect() before notifying listeners,
+                // but _connect() awaits _wait() which is async. Calling
+                // close() synchronously sets _closeCalled = true, which
+                // _connect() checks before opening the new socket.
+                rawSocket.close();
+                this._scheduleReconnect();
+            }
+            // 1006 without conversationId: let RWS handle transport-level
+            // reconnect normally (starts a fresh conversation).
+        };
+        rawSocket.addEventListener("message", onMessage);
+        rawSocket.addEventListener("close", onClose);
+        this._cleanupWireListeners = () => {
+            rawSocket.removeEventListener("message", onMessage);
+            rawSocket.removeEventListener("close", onClose);
+        };
+    }
+}
+exports.ReconnectableConversationsSocket = ReconnectableConversationsSocket;

package/dist/cjs/custom/index.d.ts

@@ -0,0 +1 @@
+export { ReconnectableConversationsSocket } from "./ReconnectableConversationsSocket.js";

package/dist/cjs/custom/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReconnectableConversationsSocket = void 0;
+var ReconnectableConversationsSocket_js_1 = require("./ReconnectableConversationsSocket.js");
+Object.defineProperty(exports, "ReconnectableConversationsSocket", { enumerable: true, get: function () { return ReconnectableConversationsSocket_js_1.ReconnectableConversationsSocket; } });

package/dist/cjs/index.d.ts

@@ -4,3 +4,4 @@ export { PhonicClient } from "./Client.js";
 export { PhonicEnvironment, type PhonicEnvironmentUrls } from "./environments.js";
 export { PhonicError, PhonicTimeoutError } from "./errors/index.js";
 export * from "./exports.js";
+export { ReconnectableConversationsSocket } from "./custom/index.js";

package/dist/cjs/index.js

@@ -36,7 +36,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PhonicTimeoutError = exports.PhonicError = exports.PhonicEnvironment = exports.PhonicClient = exports.Phonic = void 0;
+exports.ReconnectableConversationsSocket = exports.PhonicTimeoutError = exports.PhonicError = exports.PhonicEnvironment = exports.PhonicClient = exports.Phonic = void 0;
 exports.Phonic = __importStar(require("./api/index.js"));
 var Client_js_1 = require("./Client.js");
 Object.defineProperty(exports, "PhonicClient", { enumerable: true, get: function () { return Client_js_1.PhonicClient; } });
@@ -46,3 +46,5 @@ var index_js_1 = require("./errors/index.js");
 Object.defineProperty(exports, "PhonicError", { enumerable: true, get: function () { return index_js_1.PhonicError; } });
 Object.defineProperty(exports, "PhonicTimeoutError", { enumerable: true, get: function () { return index_js_1.PhonicTimeoutError; } });
 __exportStar(require("./exports.js"), exports);
+var index_js_2 = require("./custom/index.js");
+Object.defineProperty(exports, "ReconnectableConversationsSocket", { enumerable: true, get: function () { return index_js_2.ReconnectableConversationsSocket; } });

package/dist/cjs/version.d.ts

@@ -1 +1 @@
-export declare const SDK_VERSION = "0.31.9";
+export declare const SDK_VERSION = "0.31.11";

package/dist/cjs/version.js

@@ -1,4 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SDK_VERSION = void 0;
-exports.SDK_VERSION = "0.31.9";
+exports.SDK_VERSION = "0.31.11";

package/dist/esm/BaseClient.mjs

@@ -6,8 +6,8 @@ export function normalizeClientOptions(options) {
     const headers = mergeHeaders({
         "X-Fern-Language": "JavaScript",
         "X-Fern-SDK-Name": "phonic",
-        "X-Fern-SDK-Version": "0.31.9",
-        "User-Agent": "phonic/0.31.9",
+        "X-Fern-SDK-Version": "0.31.11",
+        "User-Agent": "phonic/0.31.11",
         "X-Fern-Runtime": core.RUNTIME.type,
         "X-Fern-Runtime-Version": core.RUNTIME.version,
     }, options === null || options === void 0 ? void 0 : options.headers);

package/dist/esm/Client.d.mts

@@ -9,7 +9,15 @@ import type { BaseClientOptions, BaseRequestOptions } from "./BaseClient.mjs";
 import { type NormalizedClientOptionsWithAuth } from "./BaseClient.mjs";
 import * as core from "./core/index.mjs";
 export declare namespace PhonicClient {
-    type Options = BaseClientOptions;
+    type Options = BaseClientOptions & {
+        /**
+         * When `true`, conversation WebSockets automatically reconnect after an
+         * abnormal disconnect (WebSocket close code 1006) using `reconnect_conv_id`.
+         * Defaults to `false` until the behavior is broadly validated in production;
+         * set to `true` to opt in early.
+         */
+        reconnectConversationOnAbnormalDisconnect?: boolean;
+    };
     interface RequestOptions extends BaseRequestOptions {
     }
 }

package/dist/esm/Client.mjs

@@ -1,4 +1,4 @@
-// This file was auto-generated by Fern from our API Definition.
+// Maintained manually (listed in .fernignore). Fern does not overwrite this file.
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {

package/dist/esm/api/resources/conversations/client/Client.d.mts

@@ -4,7 +4,14 @@ import * as core from "../../../../core/index.mjs";
 import * as Phonic from "../../../index.mjs";
 import { ConversationsSocket } from "./Socket.mjs";
 export declare namespace ConversationsClient {
-    type Options = BaseClientOptions;
+    type Options = BaseClientOptions & {
+        /**
+         * When `true`, `connect()` uses session-aware reconnection on abnormal
+         * disconnect (1006). Set via `PhonicClient` options as
+         * `reconnectConversationOnAbnormalDisconnect`.
+         */
+        reconnectConversationOnAbnormalDisconnect?: boolean;
+    };
     interface RequestOptions extends BaseRequestOptions {
     }
     interface ConnectArgs {

package/dist/esm/api/resources/conversations/client/Client.mjs

@@ -26,6 +26,7 @@ import * as environments from "../../../../environments.mjs";
 import { handleNonStatusCodeError } from "../../../../errors/handleNonStatusCodeError.mjs";
 import * as errors from "../../../../errors/index.mjs";
 import * as Phonic from "../../../index.mjs";
+import { ReconnectableConversationsSocket } from "../../../../custom/ReconnectableConversationsSocket.mjs";
 import { ConversationsSocket } from "./Socket.mjs";
 export class ConversationsClient {
     constructor(options = {}) {
@@ -714,11 +715,44 @@ export class ConversationsClient {
             const _queryParams = {
                 downstream_websocket_url: downstreamWebsocketUrl,
             };
+            const baseWsUrl = core.url.join((_a = (yield core.Supplier.get(this._options.baseUrl))) !== null && _a !== void 0 ? _a : ((_b = (yield core.Supplier.get(this._options.environment))) !== null && _b !== void 0 ? _b : environments.PhonicEnvironment.Default)
+                .production, "/v1/sts/ws");
+            if (this._options.reconnectConversationOnAbnormalDisconnect) {
+                const connectionTimeoutMs = connectionTimeoutInSeconds != null ? connectionTimeoutInSeconds * 1000 : undefined;
+                const createSocket = (reconnectConvId) => __awaiter(this, void 0, void 0, function* () {
+                    var _a, _b, _c;
+                    const freshAuth = yield this._options.authProvider.getAuthRequest();
+                    const mergedHeaders = Object.assign(Object.assign(Object.assign({}, ((_a = freshAuth.headers) !== null && _a !== void 0 ? _a : {})), ((_c = (_b = this._options) === null || _b === void 0 ? void 0 : _b.headers) !== null && _c !== void 0 ? _c : {})), headers);
+                    const isSessionReconnect = reconnectConvId != null;
+                    return new core.ReconnectingWebSocket({
+                        url: baseWsUrl,
+                        protocols: protocols !== null && protocols !== void 0 ? protocols : [],
+                        queryParameters: Object.assign(Object.assign(Object.assign({}, _queryParams), queryParams), (reconnectConvId ? { reconnect_conv_id: reconnectConvId } : {})),
+                        headers: mergedHeaders,
+                        options: {
+                            debug: debug !== null && debug !== void 0 ? debug : false,
+                            // Initial connection keeps transport retries; replacement sockets use 0 so only
+                            // ReconnectableConversationsSocket performs session-level reconnect.
+                            maxRetries: isSessionReconnect ? 0 : reconnectAttempts !== null && reconnectAttempts !== void 0 ? reconnectAttempts : 30,
+                            connectionTimeout: connectionTimeoutMs,
+                        },
+                        // Only pass abortSignal to the initial socket. Reconnect sockets
+                        // don't get it — each would register a new listener on the signal
+                        // that's never removed, leaking memory over many reconnects.
+                        abortSignal: isSessionReconnect ? undefined : abortSignal,
+                    });
+                });
+                const initialSocket = yield createSocket();
+                return new ReconnectableConversationsSocket({
+                    socket: initialSocket,
+                    createReconnectSocket: (conversationId) => createSocket(conversationId),
+                    abortSignal,
+                });
+            }
             const _authRequest = yield this._options.authProvider.getAuthRequest();
-            const _headers = Object.assign(Object.assign(Object.assign({}, ((_a = _authRequest.headers) !== null && _a !== void 0 ? _a : {})), ((_c = (_b = this._options) === null || _b === void 0 ? void 0 : _b.headers) !== null && _c !== void 0 ? _c : {})), headers);
+            const _headers = Object.assign(Object.assign(Object.assign({}, ((_c = _authRequest.headers) !== null && _c !== void 0 ? _c : {})), ((_e = (_d = this._options) === null || _d === void 0 ? void 0 : _d.headers) !== null && _e !== void 0 ? _e : {})), headers);
             const socket = new core.ReconnectingWebSocket({
-                url: core.url.join((_d = (yield core.Supplier.get(this._options.baseUrl))) !== null && _d !== void 0 ? _d : ((_e = (yield core.Supplier.get(this._options.environment))) !== null && _e !== void 0 ? _e : environments.PhonicEnvironment.Default)
-                    .production, "/v1/sts/ws"),
+                url: baseWsUrl,
                 protocols: protocols !== null && protocols !== void 0 ? protocols : [],
                 queryParameters: Object.assign(Object.assign({}, _queryParams), queryParams),
                 headers: _headers,

package/dist/esm/api/resources/conversations/client/Socket.d.mts

@@ -41,6 +41,7 @@ export declare class ConversationsSocket {
     sendToolCallOutput(message: Phonic.ToolCallOutputPayload): void;
     sendGenerateReply(message: Phonic.GenerateReplyPayload): void;
     sendSay(message: Phonic.SayPayload): void;
+    sendReset(message: Phonic.ResetPayload): void;
     /** Connect to the websocket and register event handlers. */
     connect(): ConversationsSocket;
     /** Close the websocket and unregister event handlers. */
@@ -52,5 +53,5 @@ export declare class ConversationsSocket {
     /** Send a binary payload to the websocket. */
     protected sendBinary(payload: ArrayBuffer | Blob | ArrayBufferView): void;
     /** Send a JSON payload to the websocket. */
-    protected sendJson(payload: Phonic.ConfigPayload | Phonic.AudioChunkPayload | Phonic.UpdateSystemPromptPayload | Phonic.AddSystemMessagePayload | Phonic.SetExternalIdPayload | Phonic.ToolCallOutputPayload | Phonic.GenerateReplyPayload | Phonic.SayPayload): void;
+    protected sendJson(payload: Phonic.ConfigPayload | Phonic.AudioChunkPayload | Phonic.UpdateSystemPromptPayload | Phonic.AddSystemMessagePayload | Phonic.SetExternalIdPayload | Phonic.ToolCallOutputPayload | Phonic.GenerateReplyPayload | Phonic.SayPayload | Phonic.ResetPayload): void;
 }

package/dist/esm/api/resources/conversations/client/Socket.mjs

@@ -86,6 +86,10 @@ export class ConversationsSocket {
         this.assertSocketIsOpen();
         this.sendJson(message);
     }
+    sendReset(message) {
+        this.assertSocketIsOpen();
+        this.sendJson(message);
+    }
     /** Connect to the websocket and register event handlers. */
     connect() {
         this.socket.reconnect();

package/dist/esm/api/types/ConfigOptions.d.mts

@@ -0,0 +1,94 @@
+/**
+ * Configuration fields for the initial `config` message.
+ */
+export interface ConfigOptions {
+    /** Agent name to use for conversation */
+    agent?: string | undefined;
+    /** Project name */
+    project?: string | undefined;
+    /** STS model to use */
+    model?: "merritt" | undefined;
+    /** System prompt for AI assistant */
+    system_prompt?: string | undefined;
+    /** Audio playback speed */
+    audio_speed?: number | undefined;
+    /** Background noise level for the conversation */
+    background_noise_level?: number | undefined;
+    /** Background noise type for the conversation */
+    background_noise?: (ConfigOptions.BackgroundNoise | null) | undefined;
+    /** When `true`, the welcome message will be automatically generated and the `welcome_message` field will be ignored. */
+    generate_welcome_message?: boolean | undefined;
+    /** Message to play when conversation starts. Ignored when `generate_welcome_message` is `true`. */
+    welcome_message?: (string | null) | undefined;
+    /** Voice ID to use for speech synthesis */
+    voice_id?: string | undefined;
+    /** Audio input format */
+    input_format?: ConfigOptions.InputFormat | undefined;
+    /** Audio output format */
+    output_format?: ConfigOptions.OutputFormat | undefined;
+    /** Voice activity detection prebuffer duration */
+    vad_prebuffer_duration_ms?: number | undefined;
+    /** Minimum speech duration for VAD */
+    vad_min_speech_duration_ms?: number | undefined;
+    /** Minimum silence duration for VAD */
+    vad_min_silence_duration_ms?: number | undefined;
+    /** Voice activity detection threshold */
+    vad_threshold?: number | undefined;
+    /** Minimum number of words required to interrupt the assistant. */
+    min_words_to_interrupt?: number | undefined;
+    /** Whether to have the no-input poke text be generated by AI */
+    generate_no_input_poke_text?: boolean | undefined;
+    /** Seconds of silence before poke message */
+    no_input_poke_sec?: (number | null) | undefined;
+    /** Poke message text. Ignored when generate_no_input_poke_text is true. */
+    no_input_poke_text?: string | undefined;
+    /** Seconds of silence before ending conversation */
+    no_input_end_conversation_sec?: number | undefined;
+    /** ISO 639-1 language code that sets the agent's default language to recognize and speak. Welcome message and no input poke text should be in this language. */
+    default_language?: string | undefined;
+    /** Array of additional ISO 639-1 language codes that the agent should be able to recognize and speak. Should not include `default_language`. */
+    additional_languages?: string[] | undefined;
+    /** If `"auto"`, each user audio is automatically identified for the language to respond in. If `"request"`, user must request to change language (recommended). */
+    multilingual_mode?: ConfigOptions.MultilingualMode | undefined;
+    /** Keywords to boost in speech recognition */
+    boosted_keywords?: string[] | undefined;
+    /** Names of tools available to the assistant. */
+    tools?: ConfigOptions.Tools.Item[] | undefined;
+    /** Template variables for system prompt and welcome message */
+    template_variables?: Record<string, string> | undefined;
+}
+export declare namespace ConfigOptions {
+    /** Background noise type for the conversation */
+    const BackgroundNoise: {
+        readonly Office: "office";
+        readonly CallCenter: "call-center";
+        readonly CoffeeShop: "coffee-shop";
+    };
+    type BackgroundNoise = (typeof BackgroundNoise)[keyof typeof BackgroundNoise];
+    /** Audio input format */
+    const InputFormat: {
+        readonly Pcm44100: "pcm_44100";
+        readonly Pcm16000: "pcm_16000";
+        readonly Pcm8000: "pcm_8000";
+        readonly Mulaw8000: "mulaw_8000";
+    };
+    type InputFormat = (typeof InputFormat)[keyof typeof InputFormat];
+    /** Audio output format */
+    const OutputFormat: {
+        readonly Pcm44100: "pcm_44100";
+        readonly Pcm16000: "pcm_16000";
+        readonly Pcm8000: "pcm_8000";
+        readonly Mulaw8000: "mulaw_8000";
+    };
+    type OutputFormat = (typeof OutputFormat)[keyof typeof OutputFormat];
+    /** If `"auto"`, each user audio is automatically identified for the language to respond in. If `"request"`, user must request to change language (recommended). */
+    const MultilingualMode: {
+        readonly Auto: "auto";
+        readonly Request: "request";
+    };
+    type MultilingualMode = (typeof MultilingualMode)[keyof typeof MultilingualMode];
+    type Tools = Tools.Item[];
+    namespace Tools {
+        type Item = string | Record<string, unknown>;
+    }
+}

package/dist/esm/api/types/ConfigOptions.mjs

@@ -0,0 +1,29 @@
+// This file was auto-generated by Fern from our API Definition.
+export var ConfigOptions;
+(function (ConfigOptions) {
+    /** Background noise type for the conversation */
+    ConfigOptions.BackgroundNoise = {
+        Office: "office",
+        CallCenter: "call-center",
+        CoffeeShop: "coffee-shop",
+    };
+    /** Audio input format */
+    ConfigOptions.InputFormat = {
+        Pcm44100: "pcm_44100",
+        Pcm16000: "pcm_16000",
+        Pcm8000: "pcm_8000",
+        Mulaw8000: "mulaw_8000",
+    };
+    /** Audio output format */
+    ConfigOptions.OutputFormat = {
+        Pcm44100: "pcm_44100",
+        Pcm16000: "pcm_16000",
+        Pcm8000: "pcm_8000",
+        Mulaw8000: "mulaw_8000",
+    };
+    /** If `"auto"`, each user audio is automatically identified for the language to respond in. If `"request"`, user must request to change language (recommended). */
+    ConfigOptions.MultilingualMode = {
+        Auto: "auto",
+        Request: "request",
+    };
+})(ConfigOptions || (ConfigOptions = {}));