@corti/sdk 0.0.0-alpha.10 → 0.0.0-rc.1

package/dist/cjs/core/websocket/ws.js

@@ -36,6 +36,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ReconnectingWebSocket = void 0;
 const ws_1 = require("ws");
 const index_js_1 = require("../runtime/index.js");
+const qs_js_1 = require("../url/qs.js");
 const Events = __importStar(require("./events.js"));
 const getGlobalWebSocket = () => {
     if (typeof WebSocket !== "undefined") {
@@ -51,7 +52,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,
@@ -63,7 +64,7 @@ const DEFAULT = {
     debug: false,
 };
 class ReconnectingWebSocket {
-    constructor(url, protocols, options = {}, headers) {
+    constructor({ url, protocols, options, headers, queryParameters }) {
         this._listeners = {
             error: [],
             message: [],
@@ -95,7 +96,7 @@ 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;
@@ -140,8 +141,9 @@ 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;
         }
@@ -280,7 +282,7 @@ 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);
@@ -320,12 +322,12 @@ class ReconnectingWebSocket {
         if (this._options.debug) {
             // not using spread because compiled version uses Symbols
             // tslint:disable-next-line
-            // eslint-disable-next-line no-console
+            // biome-ignore lint/suspicious/noConsole: allow console
             console.log.apply(console, ["RWS>", ...args]);
         }
     }
     _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);
@@ -362,7 +364,7 @@ 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;
@@ -383,6 +385,12 @@ class ReconnectingWebSocket {
             if (this._headers) {
                 options.headers = this._headers;
             }
+            if (this._queryParameters && Object.keys(this._queryParameters).length > 0) {
+                const queryString = (0, qs_js_1.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/cjs/custom/CortiAuth.d.ts

@@ -14,25 +14,33 @@
 import { Auth as FernAuth } from "../api/resources/auth/client/Client.js";
 import * as core from "../core/index.js";
 import * as Corti from "../api/index.js";
+import * as environments from "../environments.js";
 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;
 }
+type AuthOptions = Omit<FernAuth.Options, 'environment'> & {
+    environment: core.Supplier<environments.CortiEnvironment | environments.CortiEnvironmentUrls> | string;
+};
 export declare class Auth extends FernAuth {
+    /**
+     * Patch: use custom AuthOptions type to support string-based environment
+     */
+    constructor(_options: AuthOptions);
     /**
      * Patch: called custom implementation this.__getToken_custom instead of this.__getToken
      */
@@ -40,7 +48,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/cjs/custom/CortiAuth.js

@@ -54,18 +54,21 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Auth = void 0;
 const Client_js_1 = require("../api/resources/auth/client/Client.js");
 const core = __importStar(require("../core/index.js"));
 const headers_js_1 = require("../core/headers.js");
-const url_join_1 = __importDefault(require("url-join"));
+const serializers = __importStar(require("../serialization/index.js"));
 const errors = __importStar(require("../errors/index.js"));
-const environments = __importStar(require("../environments.js"));
+const getEnvironmentFromString_js_1 = require("./utils/getEnvironmentFromString.js");
 class Auth extends Client_js_1.Auth {
+    /**
+     * Patch: use custom AuthOptions type to support string-based environment
+     */
+    constructor(_options) {
+        super(Object.assign(Object.assign({}, _options), { environment: (0, getEnvironmentFromString_js_1.getEnvironment)(_options.environment) }));
+    }
     /**
      * Patch: called custom implementation this.__getToken_custom instead of this.__getToken
      */
@@ -76,17 +79,16 @@ class Auth extends Client_js_1.Auth {
      * 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((0, url_join_1.default)((_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)) {
@@ -100,7 +102,7 @@ class Auth extends Client_js_1.Auth {
      * 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
@@ -113,7 +115,7 @@ class Auth extends Client_js_1.Auth {
         return __awaiter(this, void 0, void 0, function* () {
             var _a, _b;
             const _response = yield core.fetcher({
-                url: (0, url_join_1.default)((_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)
@@ -130,18 +132,21 @@ class Auth extends Client_js_1.Auth {
                 /**
                  * 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,
@@ -149,7 +154,16 @@ class Auth extends Client_js_1.Auth {
                 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({
@@ -179,7 +193,7 @@ class Auth extends Client_js_1.Auth {
      * 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));
     }
 }
 exports.Auth = Auth;

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

@@ -14,7 +14,6 @@
  *
  * All the patches marked with `// Patch: ...` comments.
  */
-import * as environments from "../environments.js";
 import * as core from "../core/index.js";
 import { Interactions } from "../api/resources/interactions/client/Client.js";
 import { Recordings } from "../api/resources/recordings/client/Client.js";
@@ -22,6 +21,7 @@ import { Transcripts } from "../api/resources/transcripts/client/Client.js";
 import { Facts } from "../api/resources/facts/client/Client.js";
 import { Documents } from "../api/resources/documents/client/Client.js";
 import { Templates } from "../api/resources/templates/client/Client.js";
+import { Agents } from "../api/resources/agents/client/Client.js";
 /**
  * Patch: changed import to custom Stream and Transcribe implementations
  */
@@ -31,6 +31,7 @@ import { Transcribe } from "./CustomTranscribe.js";
  * Patch: added custom RefreshBearerProvider
  */
 import { BearerOptions } from "./RefreshBearerProvider.js";
+import { Environment, CortiInternalEnvironment } from "./utils/getEnvironmentFromString.js";
 export declare namespace CortiClient {
     /**
      * Patch: added new public interface for `Options` (+ `ClientCredentials` interface)
@@ -39,14 +40,33 @@ export declare namespace CortiClient {
         clientId: core.Supplier<string>;
         clientSecret: core.Supplier<string>;
     }
-    interface Options {
-        environment: core.Supplier<environments.CortiEnvironment | environments.CortiEnvironmentUrls>;
-        /** Override the Tenant-Name header */
-        tenantName: core.Supplier<string>;
+    interface BaseOptions {
         /** Additional headers to include in requests. */
         headers?: Record<string, string | core.Supplier<string | undefined> | undefined>;
-        auth: ClientCredentials | BearerOptions;
     }
+    /**
+     * Options when using Client Credentials authentication
+     * tenantName and environment are required
+     */
+    interface OptionsWithClientCredentials extends BaseOptions {
+        /**
+         * Patch: allow to pass a custom string-based environment
+         * */
+        environment: Environment;
+        /** Override the Tenant-Name header */
+        tenantName: core.Supplier<string>;
+        auth: ClientCredentials;
+    }
+    /**
+     * Options when using Bearer token authentication
+     * tenantName and environment are optional (extracted from token if not provided)
+     */
+    interface OptionsWithBearerToken extends BaseOptions {
+        environment?: Environment;
+        tenantName?: core.Supplier<string>;
+        auth: BearerOptions;
+    }
+    type Options = OptionsWithClientCredentials | OptionsWithBearerToken;
     /**
      * Patch:
      *  - renamed `Options` to `InternalOptions`
@@ -54,7 +74,7 @@ export declare namespace CortiClient {
      *  - made clientId and clientSecret optional
      */
     interface InternalOptions {
-        environment: core.Supplier<environments.CortiEnvironment | environments.CortiEnvironmentUrls>;
+        environment: CortiInternalEnvironment;
         /** Specify a custom URL to connect the client to. */
         baseUrl?: core.Supplier<string>;
         clientId?: core.Supplier<string>;
@@ -93,6 +113,7 @@ export declare class CortiClient {
     protected _facts: Facts | undefined;
     protected _templates: Templates | undefined;
     protected _documents: Documents | undefined;
+    protected _agents: Agents | undefined;
     /**
      * Patch: removed `auth` field
      * `_oauthTokenProvider` uses Auth module directly to get the token,
@@ -108,6 +129,7 @@ export declare class CortiClient {
     get facts(): Facts;
     get documents(): Documents;
     get templates(): Templates;
+    get agents(): Agents;
     get stream(): Stream;
     get transcribe(): Transcribe;
 }

package/dist/cjs/custom/CortiClient.js

@@ -71,6 +71,7 @@ const Client_js_3 = require("../api/resources/transcripts/client/Client.js");
 const Client_js_4 = require("../api/resources/facts/client/Client.js");
 const Client_js_5 = require("../api/resources/documents/client/Client.js");
 const Client_js_6 = require("../api/resources/templates/client/Client.js");
+const Client_js_7 = require("../api/resources/agents/client/Client.js");
 /**
  * Patch: changed import to custom Stream and Transcribe implementations
  */
@@ -84,10 +85,16 @@ const RefreshBearerProvider_js_1 = require("./RefreshBearerProvider.js");
  * Patch: added SDK_VERSION import
  */
 const version_js_1 = require("../version.js");
+const getEnvironmentFromString_js_1 = require("./utils/getEnvironmentFromString.js");
+const resolveClientOptions_js_1 = require("./utils/resolveClientOptions.js");
 class CortiClient {
     constructor(_options) {
+        /**
+         * Patch: resolve tenantName and environment from options or token
+         */
+        const { tenantName, environment } = (0, resolveClientOptions_js_1.resolveClientOptions)(_options);
         this._options = Object.assign(Object.assign({}, _options), { headers: (0, headers_js_1.mergeHeaders)({
-                "Tenant-Name": _options === null || _options === void 0 ? void 0 : _options.tenantName,
+                "Tenant-Name": tenantName,
                 "X-Fern-Language": "JavaScript",
                 "X-Fern-SDK-Name": "@corti/sdk",
                 /**
@@ -97,20 +104,21 @@ class CortiClient {
                 "User-Agent": `@corti/sdk/${version_js_1.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, tenantName, environment: (0, getEnvironmentFromString_js_1.getEnvironment)(environment) });
         /**
-         * Patch: if `accessToken` is provided, use BearerProvider, otherwise use OAuthTokenProvider
+         * Patch: if `clientId` is provided, use OAuthTokenProvider, otherwise use BearerProvider
          */
-        this._oauthTokenProvider = "access_token" in _options.auth ?
-            new RefreshBearerProvider_js_1.RefreshBearerProvider(_options.auth) :
-            new core.OAuthTokenProvider({
-                clientId: _options.auth.clientId,
-                clientSecret: _options.auth.clientSecret,
-                /**
-                 * Patch: provide whole `options` object to the Auth client, since it depends on both tenantName and environment
-                 */
-                authClient: new CortiAuth_js_1.Auth(this._options),
-            });
+        this._oauthTokenProvider =
+            "clientId" in _options.auth
+                ? new core.OAuthTokenProvider({
+                    clientId: _options.auth.clientId,
+                    clientSecret: _options.auth.clientSecret,
+                    /**
+                     * Patch: provide whole `options` object to the Auth client, since it depends on both tenantName and environment
+                     */
+                    authClient: new CortiAuth_js_1.Auth(this._options),
+                })
+                : new RefreshBearerProvider_js_1.RefreshBearerProvider(_options.auth);
     }
     get interactions() {
         var _a;
@@ -136,6 +144,10 @@ class CortiClient {
         var _a;
         return ((_a = this._templates) !== null && _a !== void 0 ? _a : (this._templates = new Client_js_6.Templates(Object.assign(Object.assign({}, this._options), { token: () => __awaiter(this, void 0, void 0, function* () { return yield this._oauthTokenProvider.getToken(); }) }))));
     }
+    get agents() {
+        var _a;
+        return ((_a = this._agents) !== null && _a !== void 0 ? _a : (this._agents = new Client_js_7.Agents(Object.assign(Object.assign({}, this._options), { token: () => __awaiter(this, void 0, void 0, function* () { return yield this._oauthTokenProvider.getToken(); }) }))));
+    }
     get stream() {
         var _a;
         return ((_a = this._stream) !== null && _a !== void 0 ? _a : (this._stream = new CustomStream_js_1.Stream(Object.assign(Object.assign({}, this._options), { token: () => __awaiter(this, void 0, void 0, function* () { return yield this._oauthTokenProvider.getToken(); }) }))));

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

@@ -2,14 +2,19 @@
  * Patch: use custom Stream implementation to support passing _options parameters to connection function
  */
 import { Stream as FernStream } from "../api/resources/stream/client/Client.js";
+/**
+ * Patch: added import for types and message parsing logic
+ */
+import * as api from "../api/index.js";
 /**
  * Patch: changed import to custom StreamSocket implementation
  */
 import { StreamSocket } from "./CustomStreamSocket.js";
 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({ configuration, ...args }: Omit<FernStream.ConnectArgs, 'token' | 'tenantName'> & {
+        configuration?: api.StreamConfig;
+    }): Promise<StreamSocket>;
 }

package/dist/cjs/custom/CustomStream.js

@@ -41,6 +41,17 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         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;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Stream = void 0;
 /**
@@ -48,34 +59,71 @@ exports.Stream = void 0;
  */
 const Client_js_1 = require("../api/resources/stream/client/Client.js");
 const core = __importStar(require("../core/index.js"));
+const json_js_1 = require("../core/json.js");
+const serializers = __importStar(require("../serialization/index.js"));
+const events_js_1 = require("../core/websocket/events.js");
 /**
  * Patch: changed import to custom StreamSocket implementation
  */
 const CustomStreamSocket_js_1 = require("./CustomStreamSocket.js");
-const qs = __importStar(require("qs"));
 class Stream extends Client_js_1.Stream {
-    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(_a) {
+        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"];
+            var { configuration } = _a, args = __rest(_a, ["configuration"]);
+            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 CustomStreamSocket_js_1.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 CustomStreamSocket_js_1.StreamSocket({ socket });
+            ws.socket.addEventListener('open', () => {
+                ws.sendConfiguration({
+                    type: 'config',
+                    configuration,
+                });
+            });
+            ws.socket.addEventListener('message', (event) => {
+                const data = (0, json_js_1.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 events_js_1.ErrorEvent({
+                        name: parsedResponse.value.type,
+                        message: JSON.stringify(parsedResponse.value),
+                    }, ''));
+                    ws.close();
+                    return;
+                }
+                if (parsedResponse.ok && parsedResponse.value.type === 'error') {
+                    ws.socket.dispatchEvent(new events_js_1.ErrorEvent({
+                        name: 'error',
+                        message: JSON.stringify(parsedResponse.value),
+                    }, ''));
+                    ws.close();
+                    return;
+                }
+                if (parsedResponse.ok && parsedResponse.value.type === 'ENDED') {
+                    ws.close();
+                    return;
+                }
+            });
+            return ws;
         });
     }
 }

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

@@ -3,9 +3,13 @@
  */
 import { StreamSocket as FernStreamSocket } from '../api/resources/stream/client/Socket.js';
 export declare class StreamSocket extends FernStreamSocket {
-    sendAudio(message: ArrayBuffer | string): void;
+    sendAudio(message: ArrayBufferLike | Blob | ArrayBufferView | string): void;
     /**
      * Patch: have to repeat this method, because it is private in the base class
      */
     private __assertSocketIsOpen;
+    /**
+     * Patch: added ability to remove event handlers
+     */
+    off<T extends keyof FernStreamSocket.EventHandlers>(event: T, callback?: FernStreamSocket.EventHandlers[T]): void;
 }

package/dist/cjs/custom/CustomStreamSocket.js

@@ -45,7 +45,7 @@ class StreamSocket extends Socket_js_1.StreamSocket {
             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
@@ -58,5 +58,13 @@ class StreamSocket extends Socket_js_1.StreamSocket {
             throw new Error("Socket is not open.");
         }
     }
+    /**
+     * Patch: added ability to remove event handlers
+     */
+    off(event, callback) {
+        if (!callback || callback === this.eventHandlers[event]) {
+            delete this.eventHandlers[event];
+        }
+    }
 }
 exports.StreamSocket = StreamSocket;

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

@@ -2,14 +2,19 @@
  * Patch: use custom Transcribe implementation to support passing _options parameters to connection function
  */
 import { Transcribe as FernTranscribe } from "../api/resources/transcribe/client/Client.js";
+/**
+ * Patch: added import for types and message parsing logic
+ */
+import * as api from "../api/index.js";
 /**
  * Patch: changed import to custom TranscribeSocket implementation
  */
 import { TranscribeSocket } from "./CustomTranscribeSocket.js";
 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({ configuration, ...args }?: Omit<FernTranscribe.ConnectArgs, 'token' | 'tenantName'> & {
+        configuration?: api.TranscribeConfig;
+    }): Promise<TranscribeSocket>;
 }