@corti/sdk 1.0.0-alpha → 1.0.0-alpha.1

package/dist/esm/custom/overrides/OAuthAuthProvider.mjs

@@ -0,0 +1,238 @@
+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());
+    });
+};
+import * as core from "../../core/index.mjs";
+import { CortiAuth } from "../auth/CortiAuth.mjs";
+import { OAuthAuthCodeAuthProvider } from "../auth/OAuthAuthCodeAuthProvider.mjs";
+import { OAuthPkceAuthProvider } from "../auth/OAuthPkceAuthProvider.mjs";
+import { OAuthRopcAuthProvider } from "../auth/OAuthRopcAuthProvider.mjs";
+import { BUFFER_IN_MINUTES, CLIENT_ID_PARAM, CLIENT_ID_REQUIRED_ERROR_MESSAGE, CLIENT_SECRET_PARAM, CLIENT_SECRET_REQUIRED_ERROR_MESSAGE, CODE_PARAM, CODE_VERIFIER_PARAM, getExpiresAt, PASSWORD_PARAM, REDIRECT_URI_PARAM, USERNAME_PARAM, } from "../utils/oauthAuthHelpers.mjs";
+import * as errors from "../../errors/index.mjs";
+/** Patch: Re-export for consumers; implementation shared with OAuthRopcAuthProvider, OAuthAuthCodeAuthProvider and OAuthPkceAuthProvider. */
+export { BUFFER_IN_MINUTES, CLIENT_ID_PARAM, CLIENT_ID_REQUIRED_ERROR_MESSAGE, CLIENT_SECRET_PARAM, CLIENT_SECRET_REQUIRED_ERROR_MESSAGE, CODE_PARAM, CODE_VERIFIER_PARAM, getExpiresAt, PASSWORD_PARAM, PASSWORD_REQUIRED_ERROR_MESSAGE, REDIRECT_URI_PARAM, USERNAME_PARAM, USERNAME_REQUIRED_ERROR_MESSAGE, } from "../utils/oauthAuthHelpers.mjs";
+const TOKEN_PARAM = "token";
+const TOKEN_PARAM_REQUIRED_ERROR_MESSAGE = `${TOKEN_PARAM} is required. Please provide it in options.`;
+export class OAuthAuthProvider {
+    constructor(options) {
+        this.options = options;
+        /**
+         * Patch: Use CortiAuth (real token endpoint) instead of AuthClient (fake-token).
+         */
+        this.authClient = new CortiAuth(options);
+        this.expiresAt = new Date();
+    }
+    static canCreate(options) {
+        return (options === null || options === void 0 ? void 0 : options[CLIENT_ID_PARAM]) != null && (options === null || options === void 0 ? void 0 : options[CLIENT_SECRET_PARAM]) != null;
+    }
+    clientIdSupplier() {
+        return __awaiter(this, arguments, void 0, function* ({ endpointMetadata, } = {}) {
+            const supplier = this.options[CLIENT_ID_PARAM];
+            if (supplier == null) {
+                throw new errors.CortiError({
+                    message: CLIENT_ID_REQUIRED_ERROR_MESSAGE,
+                });
+            }
+            return core.EndpointSupplier.get(supplier, { endpointMetadata });
+        });
+    }
+    clientSecretSupplier() {
+        return __awaiter(this, arguments, void 0, function* ({ endpointMetadata, } = {}) {
+            const supplier = this.options[CLIENT_SECRET_PARAM];
+            if (supplier == null) {
+                throw new errors.CortiError({
+                    message: CLIENT_SECRET_REQUIRED_ERROR_MESSAGE,
+                });
+            }
+            return core.EndpointSupplier.get(supplier, { endpointMetadata });
+        });
+    }
+    getAuthRequest() {
+        return __awaiter(this, arguments, void 0, function* ({ endpointMetadata, } = {}) {
+            const token = yield this.getToken({ endpointMetadata });
+            return {
+                headers: {
+                    Authorization: `Bearer ${token}`,
+                },
+            };
+        });
+    }
+    getToken() {
+        return __awaiter(this, arguments, void 0, function* ({ endpointMetadata } = {}) {
+            if (this.accessToken && this.expiresAt > new Date()) {
+                return this.accessToken;
+            }
+            // If a refresh is already in progress, return the existing promise
+            if (this.refreshPromise != null) {
+                return this.refreshPromise;
+            }
+            return this.refresh({ endpointMetadata });
+        });
+    }
+    refresh() {
+        return __awaiter(this, arguments, void 0, function* ({ endpointMetadata } = {}) {
+            this.refreshPromise = (() => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    const clientId = yield this.clientIdSupplier({ endpointMetadata });
+                    const clientSecret = yield this.clientSecretSupplier({ endpointMetadata });
+                    const tokenResponse = clientId && this.storedRefreshToken && this.refreshExpiresAt && this.refreshExpiresAt > new Date()
+                        ? yield this.authClient.refreshToken({
+                            clientId,
+                            refreshToken: this.storedRefreshToken,
+                        })
+                        : yield this.authClient.getToken({ clientId, clientSecret });
+                    this.accessToken = tokenResponse.accessToken;
+                    this.expiresAt = getExpiresAt(tokenResponse.expiresIn, BUFFER_IN_MINUTES);
+                    if (tokenResponse.refreshToken) {
+                        this.storedRefreshToken = tokenResponse.refreshToken;
+                        this.refreshExpiresAt = tokenResponse.refreshExpiresIn
+                            ? getExpiresAt(tokenResponse.refreshExpiresIn, BUFFER_IN_MINUTES)
+                            : undefined;
+                    }
+                    return this.accessToken;
+                }
+                finally {
+                    this.refreshPromise = undefined;
+                }
+            }))();
+            return this.refreshPromise;
+        });
+    }
+}
+export class OAuthTokenOverrideAuthProvider {
+    constructor(options) {
+        this._tokenSupplier = options[TOKEN_PARAM];
+        this._clientIdSupplier = options.clientId;
+        // Patch: store custom refresh callback
+        this._refreshAccessToken = options.refreshAccessToken;
+        this.expiresAt = options.expiresIn ? getExpiresAt(options.expiresIn, BUFFER_IN_MINUTES) : undefined;
+        this.storedRefreshToken = options.refreshToken;
+        this.refreshExpiresAt = options.refreshExpiresIn
+            ? getExpiresAt(options.refreshExpiresIn, BUFFER_IN_MINUTES)
+            : undefined;
+        if (options.clientId && options.refreshToken) {
+            this.authClient = new CortiAuth(options);
+        }
+        // Patch: pre-seed token from discovery promise so getAuthRequest doesn't call refreshAccessToken again
+        if (options.initialTokenResponse) {
+            this._seedPromise = options.initialTokenResponse
+                .then((resp) => {
+                this.accessToken = resp.accessToken;
+                this.expiresAt = resp.expiresIn ? getExpiresAt(resp.expiresIn, BUFFER_IN_MINUTES) : undefined;
+                if (resp.refreshToken) {
+                    this.storedRefreshToken = resp.refreshToken;
+                    this.refreshExpiresAt = resp.refreshExpiresIn
+                        ? getExpiresAt(resp.refreshExpiresIn, BUFFER_IN_MINUTES)
+                        : undefined;
+                }
+            })
+                .finally(() => {
+                this._seedPromise = undefined;
+            });
+        }
+    }
+    static canCreate(options) {
+        // Patch: either token or refreshAccessToken is sufficient
+        return (options === null || options === void 0 ? void 0 : options[TOKEN_PARAM]) != null || (options === null || options === void 0 ? void 0 : options.refreshAccessToken) != null;
+    }
+    getAuthRequest() {
+        return __awaiter(this, arguments, void 0, function* ({ endpointMetadata, } = {}) {
+            // Patch: await seed promise so the initial token from resolveClientOptions is set before checking expiry
+            if (this._seedPromise) {
+                yield this._seedPromise;
+            }
+            const isExpiredOrAbsent = !this.accessToken || (this.expiresAt != null && this.expiresAt <= new Date());
+            // Patch: custom refreshAccessToken takes priority — call it when token is absent or expired
+            if (this._refreshAccessToken && isExpiredOrAbsent) {
+                const result = yield this._refreshAccessToken(this.storedRefreshToken);
+                this.accessToken = result.accessToken;
+                this.expiresAt = result.expiresIn ? getExpiresAt(result.expiresIn, BUFFER_IN_MINUTES) : undefined;
+                if (result.refreshToken) {
+                    this.storedRefreshToken = result.refreshToken;
+                    this.refreshExpiresAt = result.refreshExpiresIn
+                        ? getExpiresAt(result.refreshExpiresIn, BUFFER_IN_MINUTES)
+                        : undefined;
+                }
+                return { headers: { Authorization: `Bearer ${this.accessToken}` } };
+            }
+            // Built-in: if access token is expired and we have a valid SDK refresh token, use it
+            if (this.expiresAt != null &&
+                this.expiresAt <= new Date() &&
+                this._clientIdSupplier &&
+                this.storedRefreshToken &&
+                this.refreshExpiresAt &&
+                this.refreshExpiresAt > new Date() &&
+                this.authClient) {
+                const clientId = yield core.EndpointSupplier.get(this._clientIdSupplier, { endpointMetadata });
+                const tokenResponse = yield this.authClient.refreshToken({
+                    clientId,
+                    refreshToken: this.storedRefreshToken,
+                });
+                this.accessToken = tokenResponse.accessToken;
+                this.expiresAt = getExpiresAt(tokenResponse.expiresIn, BUFFER_IN_MINUTES);
+                if (tokenResponse.refreshToken) {
+                    this.storedRefreshToken = tokenResponse.refreshToken;
+                    this.refreshExpiresAt = tokenResponse.refreshExpiresIn
+                        ? getExpiresAt(tokenResponse.refreshExpiresIn, BUFFER_IN_MINUTES)
+                        : undefined;
+                }
+                return { headers: { Authorization: `Bearer ${this.accessToken}` } };
+            }
+            // Token not yet acquired — resolve from supplier (static token / initial value)
+            if (!this.accessToken) {
+                if (this._tokenSupplier == null) {
+                    throw new errors.CortiError({ message: TOKEN_PARAM_REQUIRED_ERROR_MESSAGE });
+                }
+                this.accessToken = yield core.EndpointSupplier.get(this._tokenSupplier, { endpointMetadata });
+            }
+            if (!this.accessToken) {
+                throw new errors.CortiError({ message: TOKEN_PARAM_REQUIRED_ERROR_MESSAGE });
+            }
+            return { headers: { Authorization: `Bearer ${this.accessToken}` } };
+        });
+    }
+}
+(function (OAuthAuthProvider) {
+    OAuthAuthProvider.AUTH_SCHEME = "OAuth";
+    /** Patch: Message extended to mention ROPC (clientId, username, password). */
+    OAuthAuthProvider.AUTH_CONFIG_ERROR_MESSAGE = `Insufficient options to create OAuthAuthProvider. Please provide '${CLIENT_ID_PARAM}' and '${CLIENT_SECRET_PARAM}', or ${TOKEN_PARAM}, or ROPC (${CLIENT_ID_PARAM}, username, password).`;
+    function createInstance(options) {
+        if (OAuthTokenOverrideAuthProvider.canCreate(options)) {
+            return new OAuthTokenOverrideAuthProvider(options);
+        }
+        /** Patch: ROPC provider before client credentials so ROPC auth is used when username+password provided. */
+        if (OAuthRopcAuthProvider.canCreate(options)) {
+            return new OAuthRopcAuthProvider(options);
+        }
+        /** Patch: PKCE provider before auth code — both have clientId+code+redirectUri, but PKCE has no clientSecret. */
+        if (OAuthPkceAuthProvider.canCreate(options)) {
+            return new OAuthPkceAuthProvider(options);
+        }
+        /** Patch: Auth code provider before client credentials — both have clientId+clientSecret, code+redirectUri distinguishes auth code. */
+        if (OAuthAuthCodeAuthProvider.canCreate(options)) {
+            return new OAuthAuthCodeAuthProvider(options);
+        }
+        if (OAuthAuthProvider.canCreate(options)) {
+            return new OAuthAuthProvider(options);
+        }
+        /** Patch: No credentials provided — proxy/passthrough mode; requests are sent without an Authorization header. */
+        const partialOptions = options;
+        const hasNoCredentials = partialOptions[CLIENT_ID_PARAM] == null &&
+            partialOptions[CLIENT_SECRET_PARAM] == null &&
+            partialOptions[TOKEN_PARAM] == null &&
+            partialOptions.refreshAccessToken == null &&
+            partialOptions[USERNAME_PARAM] == null;
+        if (hasNoCredentials) {
+            return new core.NoOpAuthProvider();
+        }
+        throw new errors.CortiError({
+            message: OAuthAuthProvider.AUTH_CONFIG_ERROR_MESSAGE,
+        });
+    }
+    OAuthAuthProvider.createInstance = createInstance;
+})(OAuthAuthProvider || (OAuthAuthProvider = {}));

package/dist/esm/custom/overrides/fetcher/index.d.mts

@@ -0,0 +1,12 @@
+export type { APIResponse } from "../../../core/fetcher/APIResponse.mjs";
+export type { BinaryResponse } from "../../../core/fetcher/BinaryResponse.mjs";
+export type { EndpointMetadata } from "../../../core/fetcher/EndpointMetadata.mjs";
+export { EndpointSupplier } from "../../../core/fetcher/EndpointSupplier.mjs";
+export type { Fetcher, FetchFunction } from "../../../core/fetcher/Fetcher.mjs";
+/** Patch: withCredentials - re-export custom fetcher that injects global withCredentials default */
+export { fetcher } from "../../fetcher.mjs";
+export { getHeader } from "../../../core/fetcher/getHeader.mjs";
+export { HttpResponsePromise } from "../../../core/fetcher/HttpResponsePromise.mjs";
+export type { RawResponse, WithRawResponse } from "../../../core/fetcher/RawResponse.mjs";
+export { abortRawResponse, toRawResponse, unknownRawResponse } from "../../../core/fetcher/RawResponse.mjs";
+export { Supplier } from "../../../core/fetcher/Supplier.mjs";

package/dist/esm/custom/overrides/fetcher/index.mjs

@@ -0,0 +1,7 @@
+export { EndpointSupplier } from "../../../core/fetcher/EndpointSupplier.mjs";
+/** Patch: withCredentials - re-export custom fetcher that injects global withCredentials default */
+export { fetcher } from "../../fetcher.mjs";
+export { getHeader } from "../../../core/fetcher/getHeader.mjs";
+export { HttpResponsePromise } from "../../../core/fetcher/HttpResponsePromise.mjs";
+export { abortRawResponse, toRawResponse, unknownRawResponse } from "../../../core/fetcher/RawResponse.mjs";
+export { Supplier } from "../../../core/fetcher/Supplier.mjs";

package/dist/esm/custom/overrides/index.d.mts

@@ -0,0 +1,14 @@
+export * as Corti from "../../api/index.mjs";
+export type { BaseClientOptions, BaseRequestOptions } from "../../BaseClient.mjs";
+export { CortiEnvironment, type CortiEnvironmentUrls } from "../../environments.mjs";
+export { CortiError, CortiTimeoutError } from "../../errors/index.mjs";
+export * from "../../exports.mjs";
+export * as serialization from "../../serialization/index.mjs";
+export { CortiAuth } from "../auth/CortiAuth.mjs";
+export { CortiClient } from "../CortiClient.mjs";
+export { CortiWebSocketProxyClient } from "../CortiWebSocketProxyClient.mjs";
+export { type ProxyOptions } from "../utils/encodeHeadersAsWsProtocols.mjs";
+export { type CortiInternalEnvironment, type Environment } from "../utils/environment.mjs";
+export { CortiSDKError, CortiSDKErrorCodes } from "../CortiSDKError.mjs";
+export { ParseError } from "../../core/schemas/builders/schema-utils/ParseError.mjs";
+export { JsonError } from "../../core/schemas/builders/schema-utils/JsonError.mjs";

package/dist/esm/custom/overrides/index.mjs

@@ -0,0 +1,14 @@
+export * as Corti from "../../api/index.mjs";
+export { CortiEnvironment } from "../../environments.mjs";
+export { CortiError, CortiTimeoutError } from "../../errors/index.mjs";
+export * from "../../exports.mjs";
+export * as serialization from "../../serialization/index.mjs";
+// Custom additions / replacements
+export { CortiAuth } from "../auth/CortiAuth.mjs";
+export { CortiClient } from "../CortiClient.mjs";
+export { CortiWebSocketProxyClient } from "../CortiWebSocketProxyClient.mjs";
+export {} from "../utils/encodeHeadersAsWsProtocols.mjs";
+export {} from "../utils/environment.mjs";
+export { CortiSDKError, CortiSDKErrorCodes } from "../CortiSDKError.mjs";
+export { ParseError } from "../../core/schemas/builders/schema-utils/ParseError.mjs";
+export { JsonError } from "../../core/schemas/builders/schema-utils/JsonError.mjs";

package/dist/esm/custom/proxy/CustomProxyStream.d.mts

@@ -0,0 +1,17 @@
+import * as Corti from "../../api/index.mjs";
+import type { CustomStreamSocket } from "../stream/CustomStreamSocket.mjs";
+import type { ProxyOptions } from "../utils/encodeHeadersAsWsProtocols.mjs";
+/**
+ * Lightweight proxy stream client — no CortiClient or auth needed.
+ * Pass a proxy URL (and optionally protocols/queryParameters) directly in connect().
+ */
+export declare class CustomProxyStream {
+    private readonly _stream;
+    connect(args: {
+        proxy: ProxyOptions;
+        configuration?: Corti.StreamConfig;
+        awaitConfiguration?: boolean;
+        debug?: boolean;
+        reconnectAttempts?: number;
+    }): Promise<CustomStreamSocket>;
+}

package/dist/esm/custom/proxy/CustomProxyStream.mjs

@@ -0,0 +1,15 @@
+import * as Corti from "../../api/index.mjs";
+import { CortiEnvironment } from "../../environments.mjs";
+import { CustomStream } from "../stream/CustomStream.mjs";
+/**
+ * Lightweight proxy stream client — no CortiClient or auth needed.
+ * Pass a proxy URL (and optionally protocols/queryParameters) directly in connect().
+ */
+export class CustomProxyStream {
+    constructor() {
+        this._stream = new CustomStream({ environment: CortiEnvironment.Eu, tenantName: "" });
+    }
+    connect(args) {
+        return this._stream.connect(Object.assign(Object.assign({}, args), { id: "" }));
+    }
+}

package/dist/esm/custom/proxy/CustomProxyTranscribe.d.mts

@@ -0,0 +1,17 @@
+import * as Corti from "../../api/index.mjs";
+import type { CustomTranscribeSocket } from "../transcribe/CustomTranscribeSocket.mjs";
+import type { ProxyOptions } from "../utils/encodeHeadersAsWsProtocols.mjs";
+/**
+ * Lightweight proxy transcribe client — no CortiClient or auth needed.
+ * Pass a proxy URL (and optionally protocols/queryParameters) directly in connect().
+ */
+export declare class CustomProxyTranscribe {
+    private readonly _transcribe;
+    connect(args: {
+        proxy: ProxyOptions;
+        configuration?: Corti.TranscribeConfig;
+        awaitConfiguration?: boolean;
+        debug?: boolean;
+        reconnectAttempts?: number;
+    }): Promise<CustomTranscribeSocket>;
+}

package/dist/esm/custom/proxy/CustomProxyTranscribe.mjs

@@ -0,0 +1,18 @@
+import * as Corti from "../../api/index.mjs";
+import { CortiEnvironment } from "../../environments.mjs";
+import { CustomTranscribe } from "../transcribe/CustomTranscribe.mjs";
+/**
+ * Lightweight proxy transcribe client — no CortiClient or auth needed.
+ * Pass a proxy URL (and optionally protocols/queryParameters) directly in connect().
+ */
+export class CustomProxyTranscribe {
+    constructor() {
+        this._transcribe = new CustomTranscribe({
+            environment: CortiEnvironment.Eu,
+            tenantName: "",
+        });
+    }
+    connect(args) {
+        return this._transcribe.connect(args);
+    }
+}

package/dist/esm/custom/stream/CustomStream.d.mts

@@ -0,0 +1,39 @@
+import { StreamClient } from "../../api/resources/stream/client/Client.mjs";
+import { CustomStreamSocket } from "./CustomStreamSocket.mjs";
+import * as Corti from "../../api/index.mjs";
+import { type ProxyOptions } from "../utils/encodeHeadersAsWsProtocols.mjs";
+export type CustomStreamConnectArgs = {
+    id: string;
+    /** When provided, connect() resolves after CONFIG_ACCEPTED or rejects on failure. */
+    configuration?: Corti.StreamConfig;
+    /**
+     * When true (default), connect() resolves after CONFIG_ACCEPTED or rejects on failure.
+     * When false, returns socket immediately; config errors are dispatched as ErrorEvent.
+     */
+    awaitConfiguration?: boolean;
+    /**
+     * When provided, bypasses normal URL construction and auth. The WebSocket connects
+     * directly to proxy.url. Useful for proxy backends that handle auth themselves.
+     */
+    proxy?: ProxyOptions;
+} & Partial<Omit<StreamClient.ConnectArgs, "id" | "tenantName" | "token">>;
+export declare class CustomStream extends StreamClient {
+    private readonly _encodeHeadersAsWsProtocols;
+    constructor(options: StreamClient.Options & {
+        encodeHeadersAsWsProtocols?: boolean;
+    });
+    connect(args: CustomStreamConnectArgs): Promise<CustomStreamSocket>;
+    /**
+     * Sends configuration on open, then resolves after CONFIG_ACCEPTED.
+     * Rejects and closes socket on CONFIG_DENIED / CONFIG_MISSING / CONFIG_TIMEOUT /
+     * CONFIG_NOT_PROVIDED / connection error / ENDED.
+     */
+    private _connectWithConfigAck;
+    /**
+     * Sends configuration on open and returns the socket immediately.
+     * Config errors are dispatched as ErrorEvent and the socket is closed.
+     */
+    private _connectWithConfigListeners;
+    /** Resolves on CONFIG_ACCEPTED; rejects on rejection types, socket error, or ENDED. */
+    private _buildConfigAckPromise;
+}

package/dist/esm/custom/stream/CustomStream.mjs

@@ -0,0 +1,146 @@
+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());
+    });
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { StreamClient } from "../../api/resources/stream/client/Client.mjs";
+import { CustomStreamSocket } from "./CustomStreamSocket.mjs";
+import * as Corti from "../../api/index.mjs";
+import { ErrorEvent } from "../../core/websocket/events.mjs";
+import { parseStreamResponseType } from "./parseStreamResponseType.mjs";
+import * as core from "../../core/index.mjs";
+import { getWsProtocols } from "../utils/encodeHeadersAsWsProtocols.mjs";
+const STREAM_CONFIG_REJECTION_TYPES = [
+    Corti.StreamConfigStatusMessageType.ConfigDenied,
+    Corti.StreamConfigStatusMessageType.ConfigMissing,
+    Corti.StreamConfigStatusMessageType.ConfigTimeout,
+    Corti.StreamConfigStatusMessageType.ConfigNotProvided,
+];
+export class CustomStream extends StreamClient {
+    constructor(options) {
+        super(options);
+        this._encodeHeadersAsWsProtocols = options.encodeHeadersAsWsProtocols;
+    }
+    connect(args) {
+        const _super = Object.create(null, {
+            connect: { get: () => super.connect }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d, _e, _f, _g, _h;
+            const { configuration, awaitConfiguration = true, proxy } = args, rest = __rest(args, ["configuration", "awaitConfiguration", "proxy"]);
+            const useProxyPath = proxy || this._encodeHeadersAsWsProtocols;
+            const protocols = yield getWsProtocols(Object.assign(Object.assign({}, this._options), { encodeHeadersAsWsProtocols: this._encodeHeadersAsWsProtocols }), proxy === null || proxy === void 0 ? void 0 : proxy.protocols);
+            const socket = useProxyPath
+                ? new core.ReconnectingWebSocket({
+                    url: (_a = proxy === null || proxy === void 0 ? void 0 : proxy.url) !== null && _a !== void 0 ? _a : core.url.join((_b = (yield core.Supplier.get(this._options.baseUrl))) !== null && _b !== void 0 ? _b : (yield core.Supplier.get(this._options.environment)).wss, `/interactions/${core.url.encodePathParam(rest.id)}/streams`),
+                    protocols,
+                    queryParameters: (_c = proxy === null || proxy === void 0 ? void 0 : proxy.queryParameters) !== null && _c !== void 0 ? _c : {},
+                    headers: (_d = rest.headers) !== null && _d !== void 0 ? _d : {},
+                    options: { debug: (_e = rest.debug) !== null && _e !== void 0 ? _e : false, maxRetries: (_f = rest.reconnectAttempts) !== null && _f !== void 0 ? _f : 30 },
+                })
+                : (yield _super.connect.call(this, Object.assign(Object.assign({}, rest), { token: ((_h = (yield ((_g = this._options.authProvider) === null || _g === void 0 ? void 0 : _g.getAuthRequest()))) === null || _h === void 0 ? void 0 : _h.headers.Authorization) || "", tenantName: yield core.Supplier.get(this._options.tenantName) }))).socket;
+            const ws = new CustomStreamSocket({ socket });
+            if (!configuration) {
+                return ws;
+            }
+            if (awaitConfiguration) {
+                return this._connectWithConfigAck(ws, configuration);
+            }
+            return this._connectWithConfigListeners(ws, configuration);
+        });
+    }
+    /**
+     * Sends configuration on open, then resolves after CONFIG_ACCEPTED.
+     * Rejects and closes socket on CONFIG_DENIED / CONFIG_MISSING / CONFIG_TIMEOUT /
+     * CONFIG_NOT_PROVIDED / connection error / ENDED.
+     */
+    _connectWithConfigAck(socket, configuration) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const configAck = this._buildConfigAckPromise(socket);
+            yield socket.waitForOpen();
+            socket.sendConfiguration({ type: "config", configuration });
+            try {
+                yield configAck;
+            }
+            catch (err) {
+                socket.close();
+                throw err;
+            }
+            // Persistent listener re-sends config on each reconnect
+            socket.socket.addEventListener("open", () => {
+                socket.sendConfiguration({ type: "config", configuration });
+            });
+            return socket;
+        });
+    }
+    /**
+     * Sends configuration on open and returns the socket immediately.
+     * Config errors are dispatched as ErrorEvent and the socket is closed.
+     */
+    _connectWithConfigListeners(socket, configuration) {
+        socket.socket.addEventListener("open", () => {
+            socket.sendConfiguration({ type: "config", configuration });
+        });
+        socket.socket.addEventListener("message", (event) => {
+            const type = parseStreamResponseType(event.data);
+            if (type == null || type === Corti.StreamConfigStatusMessageType.ConfigAccepted) {
+                return;
+            }
+            if (STREAM_CONFIG_REJECTION_TYPES.includes(type) || type === "error") {
+                socket.socket.dispatchEvent(new ErrorEvent(new Error(type), socket.socket));
+                socket.close();
+            }
+            else if (type === "ENDED") {
+                socket.close();
+            }
+        });
+        return socket;
+    }
+    /** Resolves on CONFIG_ACCEPTED; rejects on rejection types, socket error, or ENDED. */
+    _buildConfigAckPromise(socket) {
+        return new Promise((resolve, reject) => {
+            const cleanup = () => {
+                socket.socket.removeEventListener("message", onMessage);
+                socket.socket.removeEventListener("error", onError);
+            };
+            const onError = (event) => {
+                cleanup();
+                reject(new Error(event.message));
+            };
+            const onMessage = (event) => {
+                const type = parseStreamResponseType(event.data);
+                if (type == null)
+                    return;
+                if (type === Corti.StreamConfigStatusMessageType.ConfigAccepted) {
+                    cleanup();
+                    resolve();
+                }
+                else if (STREAM_CONFIG_REJECTION_TYPES.includes(type)) {
+                    cleanup();
+                    reject(new Error(type));
+                }
+                else if (type === "ENDED") {
+                    cleanup();
+                    reject(new Error("Connection ended before config was accepted"));
+                }
+            };
+            socket.socket.addEventListener("message", onMessage);
+            socket.socket.addEventListener("error", onError);
+        });
+    }
+}

package/dist/esm/custom/stream/CustomStreamSocket.d.mts

@@ -0,0 +1,7 @@
+import { StreamSocket } from "../../api/resources/stream/client/Socket.mjs";
+export declare class CustomStreamSocket extends StreamSocket {
+    /** Remove the handler for an event. If callback is supplied, only removes if it matches. */
+    off<T extends keyof StreamSocket.EventHandlers>(event: T, callback?: StreamSocket.EventHandlers[T]): void;
+    /** Send raw data directly on the underlying WebSocket (e.g. binary audio, custom frames). */
+    send(data: string | ArrayBufferLike | Blob | ArrayBufferView): void;
+}

package/dist/esm/custom/stream/CustomStreamSocket.mjs

@@ -0,0 +1,13 @@
+import { StreamSocket } from "../../api/resources/stream/client/Socket.mjs";
+export class CustomStreamSocket extends StreamSocket {
+    /** Remove the handler for an event. If callback is supplied, only removes if it matches. */
+    off(event, callback) {
+        if (callback === undefined || this.eventHandlers[event] === callback) {
+            this.eventHandlers[event] = undefined;
+        }
+    }
+    /** Send raw data directly on the underlying WebSocket (e.g. binary audio, custom frames). */
+    send(data) {
+        this.socket.send(data);
+    }
+}

package/dist/esm/custom/stream/parseStreamResponseType.d.mts

@@ -0,0 +1,2 @@
+/** Parses a raw WebSocket message and returns its type string, or null on failure. */
+export declare function parseStreamResponseType(raw: string): string | null;

package/dist/esm/custom/stream/parseStreamResponseType.mjs

@@ -0,0 +1,13 @@
+import { fromJson } from "../../core/json.mjs";
+import * as serializers from "../../serialization/index.mjs";
+/** Parses a raw WebSocket message and returns its type string, or null on failure. */
+export function parseStreamResponseType(raw) {
+    const parsed = serializers.StreamSocketResponse.parse(fromJson(raw), {
+        unrecognizedObjectKeys: "passthrough",
+        allowUnrecognizedUnionMembers: true,
+        allowUnrecognizedEnumValues: true,
+        skipValidation: true,
+        omitUndefined: true,
+    });
+    return parsed.ok ? parsed.value.type : null;
+}

package/dist/esm/custom/transcribe/CustomTranscribe.d.mts

@@ -0,0 +1,38 @@
+import { TranscribeClient } from "../../api/resources/transcribe/client/Client.mjs";
+import { CustomTranscribeSocket } from "./CustomTranscribeSocket.mjs";
+import * as Corti from "../../api/index.mjs";
+import { type ProxyOptions } from "../utils/encodeHeadersAsWsProtocols.mjs";
+export type CustomTranscribeConnectArgs = {
+    /** When provided, connect() resolves after CONFIG_ACCEPTED or rejects on failure. */
+    configuration?: Corti.TranscribeConfig;
+    /**
+     * When true (default), connect() resolves after CONFIG_ACCEPTED or rejects on failure.
+     * When false, returns socket immediately; config errors are dispatched as ErrorEvent.
+     */
+    awaitConfiguration?: boolean;
+    /**
+     * When provided, bypasses normal URL construction and auth. The WebSocket connects
+     * directly to proxy.url. Useful for proxy backends that handle auth themselves.
+     */
+    proxy?: ProxyOptions;
+} & Partial<Omit<TranscribeClient.ConnectArgs, "tenantName" | "token">>;
+export declare class CustomTranscribe extends TranscribeClient {
+    private readonly _encodeHeadersAsWsProtocols;
+    constructor(options: TranscribeClient.Options & {
+        encodeHeadersAsWsProtocols?: boolean;
+    });
+    connect(args?: CustomTranscribeConnectArgs): Promise<CustomTranscribeSocket>;
+    /**
+     * Sends configuration on open, then resolves after CONFIG_ACCEPTED.
+     * Rejects and closes socket on CONFIG_DENIED / CONFIG_TIMEOUT /
+     * connection error / ended.
+     */
+    private _connectWithConfigAck;
+    /**
+     * Sends configuration on open and returns the socket immediately.
+     * Config errors are dispatched as ErrorEvent and the socket is closed.
+     */
+    private _connectWithConfigListeners;
+    /** Resolves on CONFIG_ACCEPTED; rejects on rejection types, socket error, or ended. */
+    private _buildConfigAckPromise;
+}