@corti/sdk 0.0.0-alpha.10 → 0.1.0-alpha

package/dist/esm/core/schemas/utils/maybeSkipValidation.mjs

@@ -0,0 +1,24 @@
+export function maybeSkipValidation(schema) {
+    return Object.assign(Object.assign({}, schema), { json: transformAndMaybeSkipValidation(schema.json), parse: transformAndMaybeSkipValidation(schema.parse) });
+}
+function transformAndMaybeSkipValidation(transform) {
+    return (value, opts) => {
+        const transformed = transform(value, opts);
+        const { skipValidation = false } = opts !== null && opts !== void 0 ? opts : {};
+        if (!transformed.ok && skipValidation) {
+            // eslint-disable-next-line no-console
+            console.warn([
+                "Failed to validate.",
+                ...transformed.errors.map((error) => "  - " +
+                    (error.path.length > 0 ? `${error.path.join(".")}: ${error.message}` : error.message)),
+            ].join("\n"));
+            return {
+                ok: true,
+                value: value,
+            };
+        }
+        else {
+            return transformed;
+        }
+    };
+}

package/dist/esm/core/schemas/utils/partition.d.mts

@@ -0,0 +1 @@
+export declare function partition<T>(items: readonly T[], predicate: (item: T) => boolean): [T[], T[]];

package/dist/esm/core/schemas/utils/partition.mjs

@@ -0,0 +1,12 @@
+export function partition(items, predicate) {
+    const trueItems = [], falseItems = [];
+    for (const item of items) {
+        if (predicate(item)) {
+            trueItems.push(item);
+        }
+        else {
+            falseItems.push(item);
+        }
+    }
+    return [trueItems, falseItems];
+}

package/dist/esm/core/url/index.d.mts

@@ -0,0 +1,2 @@
+export { join } from "./join.mjs";
+export { toQueryString } from "./qs.mjs";

package/dist/esm/core/url/index.mjs

@@ -0,0 +1,2 @@
+export { join } from "./join.mjs";
+export { toQueryString } from "./qs.mjs";

package/dist/esm/core/url/join.d.mts

@@ -0,0 +1 @@
+export declare function join(base: string, ...segments: string[]): string;

package/dist/esm/core/url/join.mjs

@@ -0,0 +1,46 @@
+export function join(base, ...segments) {
+    if (!base) {
+        return "";
+    }
+    if (base.includes("://")) {
+        let url;
+        try {
+            url = new URL(base);
+        }
+        catch (_a) {
+            // Fallback to path joining if URL is malformed
+            return joinPath(base, ...segments);
+        }
+        for (const segment of segments) {
+            const cleanSegment = trimSlashes(segment);
+            if (cleanSegment) {
+                url.pathname = joinPathSegments(url.pathname, cleanSegment);
+            }
+        }
+        return url.toString();
+    }
+    return joinPath(base, ...segments);
+}
+function joinPath(base, ...segments) {
+    let result = base;
+    for (const segment of segments) {
+        const cleanSegment = trimSlashes(segment);
+        if (cleanSegment) {
+            result = joinPathSegments(result, cleanSegment);
+        }
+    }
+    return result;
+}
+function joinPathSegments(left, right) {
+    if (left.endsWith("/")) {
+        return left + right;
+    }
+    return left + "/" + right;
+}
+function trimSlashes(str) {
+    if (!str)
+        return str;
+    let start = str.startsWith("/") ? 1 : 0;
+    let end = str.endsWith("/") ? str.length - 1 : str.length;
+    return str.slice(start, end);
+}

package/dist/esm/core/url/qs.d.mts

@@ -0,0 +1,6 @@
+interface QueryStringOptions {
+    arrayFormat?: "indices" | "repeat";
+    encode?: boolean;
+}
+export declare function toQueryString(obj: unknown, options?: QueryStringOptions): string;
+export {};

package/dist/esm/core/url/qs.mjs

@@ -0,0 +1,61 @@
+const defaultQsOptions = {
+    arrayFormat: "indices",
+    encode: true,
+};
+function encodeValue(value, shouldEncode) {
+    if (value === undefined) {
+        return "";
+    }
+    if (value === null) {
+        return "";
+    }
+    const stringValue = String(value);
+    return shouldEncode ? encodeURIComponent(stringValue) : stringValue;
+}
+function stringifyObject(obj, prefix = "", options) {
+    const parts = [];
+    for (const [key, value] of Object.entries(obj)) {
+        const fullKey = prefix ? `${prefix}[${key}]` : key;
+        if (value === undefined) {
+            continue;
+        }
+        if (Array.isArray(value)) {
+            if (value.length === 0) {
+                continue;
+            }
+            for (let i = 0; i < value.length; i++) {
+                const item = value[i];
+                if (item === undefined) {
+                    continue;
+                }
+                if (typeof item === "object" && !Array.isArray(item) && item !== null) {
+                    const arrayKey = options.arrayFormat === "indices" ? `${fullKey}[${i}]` : fullKey;
+                    parts.push(...stringifyObject(item, arrayKey, options));
+                }
+                else {
+                    const arrayKey = options.arrayFormat === "indices" ? `${fullKey}[${i}]` : fullKey;
+                    const encodedKey = options.encode ? encodeURIComponent(arrayKey) : arrayKey;
+                    parts.push(`${encodedKey}=${encodeValue(item, options.encode)}`);
+                }
+            }
+        }
+        else if (typeof value === "object" && value !== null) {
+            if (Object.keys(value).length === 0) {
+                continue;
+            }
+            parts.push(...stringifyObject(value, fullKey, options));
+        }
+        else {
+            const encodedKey = options.encode ? encodeURIComponent(fullKey) : fullKey;
+            parts.push(`${encodedKey}=${encodeValue(value, options.encode)}`);
+        }
+    }
+    return parts;
+}
+export function toQueryString(obj, options) {
+    if (obj == null || typeof obj !== "object") {
+        return "";
+    }
+    const parts = stringifyObject(obj, "", Object.assign(Object.assign({}, defaultQsOptions), options));
+    return parts.join("&");
+}

package/dist/esm/core/websocket/ws.d.mts

@@ -2,26 +2,35 @@ import * as Events from "./events.mjs";
 export type Event = Events.Event;
 export type ErrorEvent = Events.ErrorEvent;
 export type CloseEvent = Events.CloseEvent;
-export type Options = {
-    WebSocket?: any;
-    maxReconnectionDelay?: number;
-    minReconnectionDelay?: number;
-    reconnectionDelayGrowFactor?: number;
-    minUptime?: number;
-    connectionTimeout?: number;
-    maxRetries?: number;
-    maxEnqueuedMessages?: number;
-    startClosed?: boolean;
-    debug?: boolean;
-};
-export type UrlProvider = string | (() => string) | (() => Promise<string>);
-export type Message = string | ArrayBuffer | Blob | ArrayBufferView;
-export type ListenersMap = {
-    error: Array<Events.WebSocketEventListenerMap["error"]>;
-    message: Array<Events.WebSocketEventListenerMap["message"]>;
-    open: Array<Events.WebSocketEventListenerMap["open"]>;
-    close: Array<Events.WebSocketEventListenerMap["close"]>;
-};
+export declare namespace ReconnectingWebSocket {
+    interface Args {
+        url: string;
+        protocols?: string | string[];
+        options?: ReconnectingWebSocket.Options;
+        headers?: Record<string, string>;
+        queryParameters?: Record<string, string | string[] | object | object[] | null | undefined>;
+    }
+    type Options = {
+        WebSocket?: any;
+        maxReconnectionDelay?: number;
+        minReconnectionDelay?: number;
+        reconnectionDelayGrowFactor?: number;
+        minUptime?: number;
+        connectionTimeout?: number;
+        maxRetries?: number;
+        maxEnqueuedMessages?: number;
+        startClosed?: boolean;
+        debug?: boolean;
+    };
+    type UrlProvider = string | (() => string) | (() => Promise<string>);
+    type Message = string | ArrayBuffer | Blob | ArrayBufferView;
+    type ListenersMap = {
+        error: Array<Events.WebSocketEventListenerMap["error"]>;
+        message: Array<Events.WebSocketEventListenerMap["message"]>;
+        open: Array<Events.WebSocketEventListenerMap["open"]>;
+        close: Array<Events.WebSocketEventListenerMap["close"]>;
+    };
+}
 export declare class ReconnectingWebSocket {
     private _ws?;
     private _listeners;
@@ -37,7 +46,8 @@ export declare class ReconnectingWebSocket {
     private readonly _protocols?;
     private readonly _options;
     private readonly _headers?;
-    constructor(url: UrlProvider, protocols?: string | string[], options?: Options, headers?: Record<string, any>);
+    private readonly _queryParameters?;
+    constructor({ url, protocols, options, headers, queryParameters }: ReconnectingWebSocket.Args);
     static get CONNECTING(): number;
     static get OPEN(): number;
     static get CLOSING(): number;
@@ -108,7 +118,7 @@ export declare class ReconnectingWebSocket {
     /**
      * Enqueue specified data to be transmitted to the server over the WebSocket connection
      */
-    send(data: Message): void;
+    send(data: ReconnectingWebSocket.Message): void;
     /**
      * Register an event handler of a specific event type
      */

package/dist/esm/core/websocket/ws.mjs

@@ -1,5 +1,6 @@
 import { WebSocket as NodeWebSocket } from "ws";
 import { RUNTIME } from "../runtime/index.mjs";
+import { toQueryString } from "../url/qs.mjs";
 import * as Events from "./events.mjs";
 const getGlobalWebSocket = () => {
     if (typeof WebSocket !== "undefined") {
@@ -15,7 +16,7 @@ const getGlobalWebSocket = () => {
  * Returns true if given argument looks like a WebSocket class
  */
 const isWebSocket = (w) => typeof w !== "undefined" && !!w && w.CLOSING === 2;
-const DEFAULT = {
+const DEFAULT_OPTIONS = {
     maxReconnectionDelay: 10000,
     minReconnectionDelay: 1000 + Math.random() * 4000,
     minUptime: 5000,
@@ -27,7 +28,7 @@ const DEFAULT = {
     debug: false,
 };
 export class ReconnectingWebSocket {
-    constructor(url, protocols, options = {}, headers) {
+    constructor({ url, protocols, options, headers, queryParameters }) {
         this._listeners = {
             error: [],
             message: [],
@@ -59,7 +60,7 @@ export class ReconnectingWebSocket {
         this.onopen = null;
         this._handleOpen = (event) => {
             this._debug("open event");
-            const { minUptime = DEFAULT.minUptime } = this._options;
+            const { minUptime = DEFAULT_OPTIONS.minUptime } = this._options;
             clearTimeout(this._connectTimeout);
             this._uptimeTimeout = setTimeout(() => this._acceptOpen(), minUptime);
             this._ws.binaryType = this._binaryType;
@@ -104,8 +105,9 @@ export class ReconnectingWebSocket {
         };
         this._url = url;
         this._protocols = protocols;
-        this._options = options;
+        this._options = options !== null && options !== void 0 ? options : DEFAULT_OPTIONS;
         this._headers = headers;
+        this._queryParameters = queryParameters;
         if (this._options.startClosed) {
             this._shouldReconnect = false;
         }
@@ -244,7 +246,7 @@ export class ReconnectingWebSocket {
             this._ws.send(data);
         }
         else {
-            const { maxEnqueuedMessages = DEFAULT.maxEnqueuedMessages } = this._options;
+            const { maxEnqueuedMessages = DEFAULT_OPTIONS.maxEnqueuedMessages } = this._options;
             if (this._messageQueue.length < maxEnqueuedMessages) {
                 this._debug("enqueue", data);
                 this._messageQueue.push(data);
@@ -289,7 +291,7 @@ export class ReconnectingWebSocket {
         }
     }
     _getNextDelay() {
-        const { reconnectionDelayGrowFactor = DEFAULT.reconnectionDelayGrowFactor, minReconnectionDelay = DEFAULT.minReconnectionDelay, maxReconnectionDelay = DEFAULT.maxReconnectionDelay, } = this._options;
+        const { reconnectionDelayGrowFactor = DEFAULT_OPTIONS.reconnectionDelayGrowFactor, minReconnectionDelay = DEFAULT_OPTIONS.minReconnectionDelay, maxReconnectionDelay = DEFAULT_OPTIONS.maxReconnectionDelay, } = this._options;
         let delay = 0;
         if (this._retryCount > 0) {
             delay = minReconnectionDelay * Math.pow(reconnectionDelayGrowFactor, this._retryCount - 1);
@@ -326,7 +328,7 @@ export class ReconnectingWebSocket {
             return;
         }
         this._connectLock = true;
-        const { maxRetries = DEFAULT.maxRetries, connectionTimeout = DEFAULT.connectionTimeout, WebSocket = getGlobalWebSocket(), } = this._options;
+        const { maxRetries = DEFAULT_OPTIONS.maxRetries, connectionTimeout = DEFAULT_OPTIONS.connectionTimeout, WebSocket = getGlobalWebSocket(), } = this._options;
         if (this._retryCount >= maxRetries) {
             this._debug("max retries reached", this._retryCount, ">=", maxRetries);
             return;
@@ -347,6 +349,12 @@ export class ReconnectingWebSocket {
             if (this._headers) {
                 options.headers = this._headers;
             }
+            if (this._queryParameters && Object.keys(this._queryParameters).length > 0) {
+                const queryString = toQueryString(this._queryParameters, { arrayFormat: "repeat" });
+                if (queryString) {
+                    url = `${url}?${queryString}`;
+                }
+            }
             this._ws = new WebSocket(url, this._protocols, options);
             this._ws.binaryType = this._binaryType;
             this._connectLock = false;

package/dist/esm/custom/CortiAuth.d.mts

@@ -15,19 +15,19 @@ import { Auth as FernAuth } from "../api/resources/auth/client/Client.mjs";
 import * as core from "../core/index.mjs";
 import * as Corti from "../api/index.mjs";
 interface AuthorizationCodeClient {
-    client_id: string;
-    redirect_uri: string;
+    clientId: string;
+    redirectUri: string;
 }
 interface AuthorizationCodeServer {
-    client_id: string;
-    client_secret: string;
-    redirect_uri: string;
+    clientId: string;
+    clientSecret: string;
+    redirectUri: string;
     code: string;
 }
 interface AuthorizationRefreshServer {
-    client_id: string;
-    client_secret: string;
-    refresh_token: string;
+    clientId: string;
+    clientSecret: string;
+    refreshToken: string;
 }
 interface Options {
     skipRedirect?: boolean;
@@ -40,7 +40,7 @@ export declare class Auth extends FernAuth {
     /**
      * Patch: added method to get Authorization URL for Authorization code flow
      */
-    authorizeURL({ client_id, redirect_uri, }: AuthorizationCodeClient, options?: Options): Promise<string>;
+    authorizeURL({ clientId, redirectUri, }: AuthorizationCodeClient, options?: Options): Promise<string>;
     /**
      * Patch: calls __getToken_custom with additional fields to support Authorization code flow
      */

package/dist/esm/custom/CortiAuth.mjs

@@ -23,9 +23,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 import { Auth as FernAuth } from "../api/resources/auth/client/Client.mjs";
 import * as core from "../core/index.mjs";
 import { mergeHeaders, mergeOnlyDefinedHeaders } from "../core/headers.mjs";
-import urlJoin from "url-join";
+import * as serializers from "../serialization/index.mjs";
 import * as errors from "../errors/index.mjs";
-import * as environments from "../environments.mjs";
 export class Auth extends FernAuth {
     /**
      * Patch: called custom implementation this.__getToken_custom instead of this.__getToken
@@ -37,17 +36,16 @@ export class Auth extends FernAuth {
      * Patch: added method to get Authorization URL for Authorization code flow
      */
     authorizeURL(_a, options_1) {
-        return __awaiter(this, arguments, void 0, function* ({ client_id, redirect_uri, }, options) {
-            var _b, _c;
-            const authUrl = new URL(urlJoin((_b = (yield core.Supplier.get(this._options.baseUrl))) !== null && _b !== void 0 ? _b : ((_c = (yield core.Supplier.get(this._options.environment))) !== null && _c !== void 0 ? _c : environments.CortiEnvironment.BetaEu)
-                .login, yield core.Supplier.get(this._options.tenantName), "protocol/openid-connect/auth"));
+        return __awaiter(this, arguments, void 0, function* ({ clientId, redirectUri, }, options) {
+            var _b;
+            const authUrl = new URL(core.url.join((_b = (yield core.Supplier.get(this._options.baseUrl))) !== null && _b !== void 0 ? _b : (yield core.Supplier.get(this._options.environment)).login, yield core.Supplier.get(this._options.tenantName), "protocol/openid-connect/auth"));
             authUrl.searchParams.set('response_type', 'code');
             authUrl.searchParams.set('scope', 'openid profile');
-            if (client_id !== undefined) {
-                authUrl.searchParams.set('client_id', client_id);
+            if (clientId !== undefined) {
+                authUrl.searchParams.set('client_id', clientId);
             }
-            if (redirect_uri !== undefined) {
-                authUrl.searchParams.set('redirect_uri', redirect_uri);
+            if (redirectUri !== undefined) {
+                authUrl.searchParams.set('redirect_uri', redirectUri);
             }
             const authUrlString = authUrl.toString();
             if (typeof window !== "undefined" && !(options === null || options === void 0 ? void 0 : options.skipRedirect)) {
@@ -61,7 +59,7 @@ export class Auth extends FernAuth {
      * Patch: calls __getToken_custom with additional fields to support Authorization code flow
      */
     getCodeFlowToken(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__getToken_custom(Object.assign(Object.assign({}, request), { grant_type: "authorization_code" }), requestOptions));
+        return core.HttpResponsePromise.fromPromise(this.__getToken_custom(Object.assign(Object.assign({}, request), { grantType: "authorization_code" }), requestOptions));
     }
     /**
      * Patch: copy of this.__getToken with patches
@@ -74,7 +72,7 @@ export class Auth extends FernAuth {
         return __awaiter(this, void 0, void 0, function* () {
             var _a, _b;
             const _response = yield core.fetcher({
-                url: urlJoin((_a = (yield core.Supplier.get(this._options.baseUrl))) !== null && _a !== void 0 ? _a : (yield core.Supplier.get(this._options.environment)).login, 
+                url: core.url.join((_a = (yield core.Supplier.get(this._options.baseUrl))) !== null && _a !== void 0 ? _a : (yield core.Supplier.get(this._options.environment)).login, 
                 /**
                  * Patch: use tenantName as path parameter
                  *  (consider to be generated from the spec in the future)
@@ -91,18 +89,21 @@ export class Auth extends FernAuth {
                 /**
                  * Patch: removed `requestType: "json"`, made body a URLSearchParams object
                  */
-                body: new URLSearchParams(Object.assign(Object.assign(Object.assign(Object.assign({}, request), { scope: "openid", 
+                body: new URLSearchParams(Object.assign(Object.assign(Object.assign(Object.assign({}, serializers.AuthGetTokenRequest.jsonOrThrow(request, {
+                    unrecognizedObjectKeys: "strip",
+                    omitUndefined: true,
+                })), { scope: "openid", 
                     /**
                      * Patch: `grant_type` uses values from request or defaults to "client_credentials"
                      */
-                    grant_type: request.grant_type || "client_credentials" }), (request.grant_type === "authorization_code"
+                    grant_type: request.grantType || "client_credentials" }), (request.grantType === "authorization_code"
                     ? {
                         code: request.code,
-                        redirect_uri: request.redirect_uri
+                        redirect_uri: request.redirectUri
                     }
-                    : {})), (request.grant_type === "refresh_token"
+                    : {})), (request.grantType === "refresh_token"
                     ? {
-                        refresh_token: request.refresh_token,
+                        refresh_token: request.refreshToken,
                     }
                     : {}))),
                 timeoutMs: (requestOptions === null || requestOptions === void 0 ? void 0 : requestOptions.timeoutInSeconds) != null ? requestOptions.timeoutInSeconds * 1000 : 60000,
@@ -110,7 +111,16 @@ export class Auth extends FernAuth {
                 abortSignal: requestOptions === null || requestOptions === void 0 ? void 0 : requestOptions.abortSignal,
             });
             if (_response.ok) {
-                return { data: _response.body, rawResponse: _response.rawResponse };
+                return {
+                    data: serializers.GetTokenResponse.parseOrThrow(_response.body, {
+                        unrecognizedObjectKeys: "passthrough",
+                        allowUnrecognizedUnionMembers: true,
+                        allowUnrecognizedEnumValues: true,
+                        skipValidation: true,
+                        breadcrumbsPrefix: ["response"],
+                    }),
+                    rawResponse: _response.rawResponse,
+                };
             }
             if (_response.error.reason === "status-code") {
                 throw new errors.CortiError({
@@ -140,6 +150,6 @@ export class Auth extends FernAuth {
      * Patch: calls __getToken_custom with additional fields to support Refresh token flow
      */
     refreshToken(request, requestOptions) {
-        return core.HttpResponsePromise.fromPromise(this.__getToken_custom(Object.assign(Object.assign({}, request), { grant_type: "refresh_token" }), requestOptions));
+        return core.HttpResponsePromise.fromPromise(this.__getToken_custom(Object.assign(Object.assign({}, request), { grantType: "refresh_token" }), requestOptions));
     }
 }

package/dist/esm/custom/CortiClient.mjs

@@ -61,11 +61,11 @@ export class CortiClient {
                 "User-Agent": `@corti/sdk/${SDK_VERSION}`,
                 "X-Fern-Runtime": core.RUNTIME.type,
                 "X-Fern-Runtime-Version": core.RUNTIME.version,
-            }, _options === null || _options === void 0 ? void 0 : _options.headers), clientId: "clientId" in _options.auth ? _options.auth.clientId : undefined, clientSecret: "clientSecret" in _options.auth ? _options.auth.clientSecret : undefined, token: "access_token" in _options.auth ? _options.auth.access_token : undefined });
+            }, _options === null || _options === void 0 ? void 0 : _options.headers), clientId: "clientId" in _options.auth ? _options.auth.clientId : undefined, clientSecret: "clientSecret" in _options.auth ? _options.auth.clientSecret : undefined, token: "accessToken" in _options.auth ? _options.auth.accessToken : undefined });
         /**
          * Patch: if `accessToken` is provided, use BearerProvider, otherwise use OAuthTokenProvider
          */
-        this._oauthTokenProvider = "access_token" in _options.auth ?
+        this._oauthTokenProvider = "accessToken" in _options.auth ?
             new RefreshBearerProvider(_options.auth) :
             new core.OAuthTokenProvider({
                 clientId: _options.auth.clientId,

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

@@ -2,14 +2,17 @@
  * Patch: use custom Stream implementation to support passing _options parameters to connection function
  */
 import { Stream as FernStream } from "../api/resources/stream/client/Client.mjs";
+/**
+ * Patch: added import for types and message parsing logic
+ */
+import * as api from "../api/index.mjs";
 /**
  * Patch: changed import to custom StreamSocket implementation
  */
 import { StreamSocket } from "./CustomStreamSocket.mjs";
 export declare class Stream extends FernStream {
-    connect(args: Omit<FernStream.ConnectArgs, 'token' | 'tenant-name'>): Promise<StreamSocket>;
     /**
-     * Patch: temporary fix of WS URL generation, while it doesn't work from Ferns side
+     * Patch: use custom connect method to support passing _options parameters
      */
-    private __connect_patch;
+    connect(args: Omit<FernStream.ConnectArgs, 'token' | 'tenantName'>, configuration?: api.StreamConfig): Promise<StreamSocket>;
 }

package/dist/esm/custom/CustomStream.mjs

@@ -12,34 +12,62 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
  */
 import { Stream as FernStream } from "../api/resources/stream/client/Client.mjs";
 import * as core from "../core/index.mjs";
+import { fromJson } from "../core/json.mjs";
+import * as serializers from "../serialization/index.mjs";
+import { ErrorEvent } from "../core/websocket/events.mjs";
 /**
  * Patch: changed import to custom StreamSocket implementation
  */
 import { StreamSocket } from "./CustomStreamSocket.mjs";
-import * as qs from "qs";
 export class Stream extends FernStream {
-    connect(args) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.__connect_patch(Object.assign(Object.assign({}, args), { token: yield this._getAuthorizationHeader(), "tenant-name": yield core.Supplier.get(this._options.tenantName) }));
-        });
-    }
     /**
-     * Patch: temporary fix of WS URL generation, while it doesn't work from Ferns side
+     * Patch: use custom connect method to support passing _options parameters
      */
-    __connect_patch(args) {
+    connect(args, configuration) {
+        const _super = Object.create(null, {
+            connect: { get: () => super.connect }
+        });
         return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b, _c;
-            const queryParams = {};
-            if (args["tenant-name"] != null) {
-                queryParams["tenant-name"] = args["tenant-name"];
-            }
-            if (args["token"] != null) {
-                queryParams["token"] = args["token"];
+            const fernWs = yield _super.connect.call(this, Object.assign(Object.assign({}, args), { token: (yield this._getAuthorizationHeader()) || '', tenantName: yield core.Supplier.get(this._options.tenantName) }));
+            const ws = new StreamSocket({ socket: fernWs.socket });
+            if (!configuration) {
+                return ws;
             }
-            let websocketHeaders = {};
-            websocketHeaders = Object.assign(Object.assign({}, websocketHeaders), args["headers"]);
-            const socket = new core.ReconnectingWebSocket(`${(_a = (yield core.Supplier.get(this._options["baseUrl"]))) !== null && _a !== void 0 ? _a : (yield core.Supplier.get(this._options["environment"])).wss}/audio-bridge/v2/interactions/${encodeURIComponent(args["id"])}/streams?${qs.stringify(queryParams, { arrayFormat: "repeat" })}`, [], { debug: (_b = args["debug"]) !== null && _b !== void 0 ? _b : false, maxRetries: (_c = args["reconnectAttempts"]) !== null && _c !== void 0 ? _c : 30 }, websocketHeaders);
-            return new StreamSocket({ socket });
+            ws.socket.addEventListener('open', () => {
+                ws.sendConfiguration({
+                    type: 'config',
+                    configuration,
+                });
+            });
+            ws.socket.addEventListener('message', (event) => {
+                const data = fromJson(event.data);
+                const parsedResponse = serializers.StreamSocketResponse.parse(data, {
+                    unrecognizedObjectKeys: "passthrough",
+                    allowUnrecognizedUnionMembers: true,
+                    allowUnrecognizedEnumValues: true,
+                    skipValidation: true,
+                    omitUndefined: true,
+                });
+                if (parsedResponse.ok && parsedResponse.value.type === 'CONFIG_ACCEPTED') {
+                    return;
+                }
+                if (parsedResponse.ok && (parsedResponse.value.type === 'CONFIG_DENIED'
+                    || parsedResponse.value.type === 'CONFIG_MISSING'
+                    || parsedResponse.value.type === 'CONFIG_TIMEOUT'
+                    || parsedResponse.value.type === 'CONFIG_NOT_PROVIDED')) {
+                    ws.socket.dispatchEvent(new ErrorEvent({
+                        name: parsedResponse.value.type,
+                        message: `Configuration error "${parsedResponse.value.type}" : ${parsedResponse.value.reason || 'No reason provided'}`,
+                    }, ''));
+                    ws.close();
+                    return;
+                }
+                if (parsedResponse.ok && parsedResponse.value.type === 'ENDED') {
+                    ws.close();
+                    return;
+                }
+            });
+            return ws;
         });
     }
 }

package/dist/esm/custom/CustomStreamSocket.mjs

@@ -9,7 +9,7 @@ export class StreamSocket extends FernStreamSocket {
             return super.sendAudio(message);
         }
         this.__assertSocketIsOpen();
-        this.socket.send(message);
+        super.sendBinary(message);
     }
     /**
      * Patch: have to repeat this method, because it is private in the base class

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

@@ -2,14 +2,17 @@
  * Patch: use custom Transcribe implementation to support passing _options parameters to connection function
  */
 import { Transcribe as FernTranscribe } from "../api/resources/transcribe/client/Client.mjs";
+/**
+ * Patch: added import for types and message parsing logic
+ */
+import * as api from "../api/index.mjs";
 /**
  * Patch: changed import to custom TranscribeSocket implementation
  */
 import { TranscribeSocket } from "./CustomTranscribeSocket.mjs";
 export declare class Transcribe extends FernTranscribe {
-    connect(args?: Omit<FernTranscribe.ConnectArgs, 'token' | 'tenant-name'>): Promise<TranscribeSocket>;
     /**
-     * Patch: temporary fix of WS generation, while binary type isn't supported from Ferns side
+     * Patch: use custom connect method to support passing _options parameters
      */
-    private __connect_patch;
+    connect(args?: Omit<FernTranscribe.ConnectArgs, 'token' | 'tenantName'>, configuration?: api.TranscribeConfig): Promise<TranscribeSocket>;
 }