@openclaw/msteams 2026.7.1-beta.1 → 2026.7.1-beta.4

package/node_modules/@microsoft/teams.apps/node_modules/@azure/msal-node/src/client/PublicClientApplication.ts

@@ -1,376 +0,0 @@
-/*
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License.
- */
-
-import {
-    ApiId,
-    Constants,
-    LOOPBACK_SERVER_CONSTANTS,
-} from "../utils/Constants.js";
-import {
-    AuthenticationResult,
-    CommonDeviceCodeRequest,
-    AuthError,
-    ResponseMode,
-    OIDC_DEFAULT_SCOPES,
-    CodeChallengeMethodValues,
-    Constants as CommonConstants,
-    ServerError,
-    NativeRequest,
-    NativeSignOutRequest,
-    AccountInfo,
-    INativeBrokerPlugin,
-    AuthorizeResponse,
-    AADServerParamKeys,
-    ServerTelemetryManager,
-} from "@azure/msal-common/node";
-import { Configuration } from "../config/Configuration.js";
-import { ClientApplication } from "./ClientApplication.js";
-import { IPublicClientApplication } from "./IPublicClientApplication.js";
-import { DeviceCodeRequest } from "../request/DeviceCodeRequest.js";
-import { AuthorizationUrlRequest } from "../request/AuthorizationUrlRequest.js";
-import { AuthorizationCodeRequest } from "../request/AuthorizationCodeRequest.js";
-import { InteractiveRequest } from "../request/InteractiveRequest.js";
-import { NodeAuthError, NodeAuthErrorMessage } from "../error/NodeAuthError.js";
-import { LoopbackClient } from "../network/LoopbackClient.js";
-import { SilentFlowRequest } from "../request/SilentFlowRequest.js";
-import { SignOutRequest } from "../request/SignOutRequest.js";
-import { ILoopbackClient } from "../network/ILoopbackClient.js";
-import { DeviceCodeClient } from "./DeviceCodeClient.js";
-import { version } from "../packageMetadata.js";
-
-/**
- * This class is to be used to acquire tokens for public client applications (desktop, mobile). Public client applications
- * are not trusted to safely store application secrets, and therefore can only request tokens in the name of an user.
- * @public
- */
-export class PublicClientApplication
-    extends ClientApplication
-    implements IPublicClientApplication
-{
-    private nativeBrokerPlugin?: INativeBrokerPlugin;
-    private readonly skus: string;
-    /**
-     * Important attributes in the Configuration object for auth are:
-     * - clientID: the application ID of your application. You can obtain one by registering your application with our Application registration portal.
-     * - authority: the authority URL for your application.
-     *
-     * AAD authorities are of the form https://login.microsoftonline.com/\{Enter_the_Tenant_Info_Here\}.
-     * - If your application supports Accounts in one organizational directory, replace "Enter_the_Tenant_Info_Here" value with the Tenant Id or Tenant name (for example, contoso.microsoft.com).
-     * - If your application supports Accounts in any organizational directory, replace "Enter_the_Tenant_Info_Here" value with organizations.
-     * - If your application supports Accounts in any organizational directory and personal Microsoft accounts, replace "Enter_the_Tenant_Info_Here" value with common.
-     * - To restrict support to Personal Microsoft accounts only, replace "Enter_the_Tenant_Info_Here" value with consumers.
-     *
-     * Azure B2C authorities are of the form https://\{instance\}/\{tenant\}/\{policy\}. Each policy is considered
-     * its own authority. You will have to set the all of the knownAuthorities at the time of the client application
-     * construction.
-     *
-     * ADFS authorities are of the form https://\{instance\}/adfs.
-     */
-    constructor(configuration: Configuration) {
-        super(configuration);
-        if (this.config.broker.nativeBrokerPlugin) {
-            if (this.config.broker.nativeBrokerPlugin.isBrokerAvailable) {
-                this.nativeBrokerPlugin = this.config.broker.nativeBrokerPlugin;
-                this.nativeBrokerPlugin.setLogger(
-                    this.config.system.loggerOptions
-                );
-            } else {
-                this.logger.warning(
-                    "NativeBroker implementation was provided but the broker is unavailable."
-                );
-            }
-        }
-        this.skus = ServerTelemetryManager.makeExtraSkuString({
-            libraryName: Constants.MSAL_SKU,
-            libraryVersion: version,
-        });
-    }
-
-    /**
-     * Acquires a token from the authority using OAuth2.0 device code flow.
-     * This flow is designed for devices that do not have access to a browser or have input constraints.
-     * The authorization server issues a DeviceCode object with a verification code, an end-user code,
-     * and the end-user verification URI. The DeviceCode object is provided through a callback, and the end-user should be
-     * instructed to use another device to navigate to the verification URI to input credentials.
-     * Since the client cannot receive incoming requests, it polls the authorization server repeatedly
-     * until the end-user completes input of credentials.
-     */
-    public async acquireTokenByDeviceCode(
-        request: DeviceCodeRequest
-    ): Promise<AuthenticationResult | null> {
-        this.logger.info(
-            "acquireTokenByDeviceCode called",
-            request.correlationId
-        );
-        const validRequest: CommonDeviceCodeRequest = Object.assign(
-            request,
-            await this.initializeBaseRequest(request)
-        );
-        const serverTelemetryManager = this.initializeServerTelemetryManager(
-            ApiId.acquireTokenByDeviceCode,
-            validRequest.correlationId
-        );
-        try {
-            const discoveredAuthority = await this.createAuthority(
-                validRequest.authority,
-                validRequest.correlationId,
-                undefined,
-                request.azureCloudOptions
-            );
-            const deviceCodeConfig = await this.buildOauthClientConfiguration(
-                discoveredAuthority,
-                validRequest.correlationId,
-                "",
-                serverTelemetryManager
-            );
-            const deviceCodeClient = new DeviceCodeClient(deviceCodeConfig);
-            this.logger.verbose(
-                "Device code client created",
-                validRequest.correlationId
-            );
-            return await deviceCodeClient.acquireToken(validRequest);
-        } catch (e) {
-            if (e instanceof AuthError) {
-                e.setCorrelationId(validRequest.correlationId);
-            }
-            serverTelemetryManager.cacheFailedRequest(e as AuthError);
-            throw e;
-        }
-    }
-
-    /**
-     * Acquires a token interactively via the browser by requesting an authorization code then exchanging it for a token.
-     */
-    async acquireTokenInteractive(
-        request: InteractiveRequest
-    ): Promise<AuthenticationResult> {
-        const correlationId =
-            request.correlationId || this.cryptoProvider.createNewGuid();
-        this.logger.trace("acquireTokenInteractive called", correlationId);
-        const {
-            openBrowser,
-            successTemplate,
-            errorTemplate,
-            windowHandle,
-            loopbackClient: customLoopbackClient,
-            ...remainingProperties
-        } = request;
-
-        if (this.nativeBrokerPlugin) {
-            const brokerRequest: NativeRequest = {
-                ...remainingProperties,
-                clientId: this.config.auth.clientId,
-                scopes: request.scopes || OIDC_DEFAULT_SCOPES,
-                redirectUri: request.redirectUri || "",
-                authority: request.authority || this.config.auth.authority,
-                correlationId: correlationId,
-                extraParameters: {
-                    ...remainingProperties.extraQueryParameters,
-                    ...remainingProperties.tokenQueryParameters,
-                    [AADServerParamKeys.X_CLIENT_EXTRA_SKU]: this.skus,
-                },
-                accountId: remainingProperties.account?.nativeAccountId,
-            };
-            return this.nativeBrokerPlugin.acquireTokenInteractive(
-                brokerRequest,
-                windowHandle
-            );
-        }
-
-        if (request.redirectUri) {
-            // If its not a broker fallback scenario, we throw a error
-            if (!this.config.broker.nativeBrokerPlugin) {
-                throw NodeAuthError.createRedirectUriNotSupportedError();
-            }
-            // If a redirect URI is provided for a broker flow but MSAL runtime startup failed, we fall back to the browser flow and will ignore the redirect URI provided for the broker flow
-            request.redirectUri = "";
-        }
-
-        const { verifier, challenge } =
-            await this.cryptoProvider.generatePkceCodes();
-
-        const loopbackClient: ILoopbackClient =
-            customLoopbackClient || new LoopbackClient();
-
-        let authCodeResponse: AuthorizeResponse = {};
-        let authCodeListenerError: AuthError | null = null;
-        try {
-            const authCodeListener = loopbackClient
-                .listenForAuthCode(successTemplate, errorTemplate)
-                .then((response) => {
-                    authCodeResponse = response;
-                })
-                .catch((e) => {
-                    // Store the promise instead of throwing so we can control when its thrown
-                    authCodeListenerError = e;
-                });
-
-            // Wait for server to be listening
-            const redirectUri = await this.waitForRedirectUri(loopbackClient);
-
-            const validRequest: AuthorizationUrlRequest = {
-                ...remainingProperties,
-                correlationId: correlationId,
-                scopes: request.scopes || OIDC_DEFAULT_SCOPES,
-                redirectUri: redirectUri,
-                responseMode: ResponseMode.QUERY,
-                codeChallenge: challenge,
-                codeChallengeMethod: CodeChallengeMethodValues.S256,
-            };
-
-            const authCodeUrl = await this.getAuthCodeUrl(validRequest);
-            await openBrowser(authCodeUrl);
-            await authCodeListener;
-            if (authCodeListenerError) {
-                throw authCodeListenerError;
-            }
-
-            if (authCodeResponse.error) {
-                throw new ServerError(
-                    authCodeResponse.error,
-                    authCodeResponse.error_description,
-                    authCodeResponse.suberror
-                );
-            } else if (!authCodeResponse.code) {
-                throw NodeAuthError.createNoAuthCodeInResponseError();
-            }
-
-            const clientInfo = authCodeResponse.client_info;
-            const tokenRequest: AuthorizationCodeRequest = {
-                code: authCodeResponse.code,
-                codeVerifier: verifier,
-                clientInfo: clientInfo || CommonConstants.EMPTY_STRING,
-                ...validRequest,
-            };
-            return await this.acquireTokenByCode(tokenRequest); // Await this so the server doesn't close prematurely
-        } finally {
-            loopbackClient.closeServer();
-        }
-    }
-
-    /**
-     * Returns a token retrieved either from the cache or by exchanging the refresh token for a fresh access token. If brokering is enabled the token request will be serviced by the broker.
-     * @param request - developer provided SilentFlowRequest
-     * @returns
-     */
-    async acquireTokenSilent(
-        request: SilentFlowRequest
-    ): Promise<AuthenticationResult> {
-        const correlationId =
-            request.correlationId || this.cryptoProvider.createNewGuid();
-        this.logger.trace("acquireTokenSilent called", correlationId);
-
-        if (this.nativeBrokerPlugin) {
-            const brokerRequest: NativeRequest = {
-                ...request,
-                clientId: this.config.auth.clientId,
-                scopes: request.scopes || OIDC_DEFAULT_SCOPES,
-                redirectUri: request.redirectUri || "",
-                authority: request.authority || this.config.auth.authority,
-                correlationId: correlationId,
-                extraParameters: {
-                    ...request.tokenQueryParameters,
-                    [AADServerParamKeys.X_CLIENT_EXTRA_SKU]: this.skus,
-                },
-                accountId: request.account.nativeAccountId,
-                forceRefresh: request.forceRefresh || false,
-            };
-            return this.nativeBrokerPlugin.acquireTokenSilent(brokerRequest);
-        }
-
-        if (request.redirectUri) {
-            // If its not a broker fallback scenario, we throw a error
-            if (!this.config.broker.nativeBrokerPlugin) {
-                throw NodeAuthError.createRedirectUriNotSupportedError();
-            }
-            request.redirectUri = "";
-        }
-
-        return super.acquireTokenSilent(request);
-    }
-
-    /**
-     * Removes cache artifacts associated with the given account
-     * @param request - developer provided SignOutRequest
-     * @returns
-     */
-    async signOut(request: SignOutRequest): Promise<void> {
-        if (this.nativeBrokerPlugin && request.account.nativeAccountId) {
-            const signoutRequest: NativeSignOutRequest = {
-                clientId: this.config.auth.clientId,
-                accountId: request.account.nativeAccountId,
-                correlationId:
-                    request.correlationId ||
-                    this.cryptoProvider.createNewGuid(),
-            };
-            await this.nativeBrokerPlugin.signOut(signoutRequest);
-        }
-
-        await this.getTokenCache().removeAccount(
-            request.account,
-            request.correlationId
-        );
-    }
-
-    /**
-     * Returns all cached accounts for this application. If brokering is enabled this request will be serviced by the broker.
-     * @returns
-     */
-    async getAllAccounts(): Promise<AccountInfo[]> {
-        if (this.nativeBrokerPlugin) {
-            const correlationId = this.cryptoProvider.createNewGuid();
-            return this.nativeBrokerPlugin.getAllAccounts(
-                this.config.auth.clientId,
-                correlationId
-            );
-        }
-
-        return this.getTokenCache().getAllAccounts();
-    }
-
-    /**
-     * Attempts to retrieve the redirectUri from the loopback server. If the loopback server does not start listening for requests within the timeout this will throw.
-     * @param loopbackClient - developer provided custom loopback server implementation
-     * @returns
-     */
-    private async waitForRedirectUri(
-        loopbackClient: ILoopbackClient
-    ): Promise<string> {
-        return new Promise<string>((resolve, reject) => {
-            let ticks = 0;
-            const id = setInterval(() => {
-                if (
-                    LOOPBACK_SERVER_CONSTANTS.TIMEOUT_MS /
-                        LOOPBACK_SERVER_CONSTANTS.INTERVAL_MS <
-                    ticks
-                ) {
-                    clearInterval(id);
-                    reject(NodeAuthError.createLoopbackServerTimeoutError());
-                    return;
-                }
-
-                try {
-                    const r = loopbackClient.getRedirectUri();
-                    clearInterval(id);
-                    resolve(r);
-                    return;
-                } catch (e) {
-                    if (
-                        e instanceof AuthError &&
-                        e.errorCode ===
-                            NodeAuthErrorMessage.noLoopbackServerExists.code
-                    ) {
-                        // Loopback server is not listening yet
-                        ticks++;
-                        return;
-                    }
-                    clearInterval(id);
-                    reject(e);
-                    return;
-                }
-            }, LOOPBACK_SERVER_CONSTANTS.INTERVAL_MS);
-        });
-    }
-}

package/node_modules/@microsoft/teams.apps/node_modules/@azure/msal-node/src/config/Configuration.ts

@@ -1,291 +0,0 @@
-/*
- * Copyright (c) Microsoft Corporation. All rights reserved.
- * Licensed under the MIT License.
- */
-
-import {
-    LoggerOptions,
-    INetworkModule,
-    LogLevel,
-    ProtocolMode,
-    ICachePlugin,
-    Constants,
-    AzureCloudInstance,
-    AzureCloudOptions,
-    ApplicationTelemetry,
-    INativeBrokerPlugin,
-    ClientAssertionCallback,
-} from "@azure/msal-common/node";
-import { HttpClient } from "../network/HttpClient.js";
-import http from "http";
-import https from "https";
-import { ManagedIdentityId } from "./ManagedIdentityId.js";
-import { NodeAuthError } from "../error/NodeAuthError.js";
-
-/**
- * - clientId               - Client id of the application.
- * - authority              - Url of the authority. If no value is set, defaults to https://login.microsoftonline.com/common.
- * - knownAuthorities       - Needed for Azure B2C and ADFS. All authorities that will be used in the client application. Only the host of the authority should be passed in.
- * - clientSecret           - Secret string that the application uses when requesting a token. Only used in confidential client applications. Can be created in the Azure app registration portal.
- * - clientAssertion        - A ClientAssertion object containing an assertion string or a callback function that returns an assertion string that the application uses when requesting a token, as well as the assertion's type (urn:ietf:params:oauth:client-assertion-type:jwt-bearer). Only used in confidential client applications.
- * - clientCertificate      - Certificate that the application uses when requesting a token. Only used in confidential client applications. Requires hex encoded X.509 SHA-1 or SHA-256 thumbprint of the certificate, and the PEM encoded private key (string should contain -----BEGIN PRIVATE KEY----- ... -----END PRIVATE KEY----- )
- * - protocolMode           - Enum that represents the protocol that msal follows. Used for configuring proper endpoints.
- * - skipAuthorityMetadataCache - A flag to choose whether to use or not use the local metadata cache during authority initialization. Defaults to false.
- * - encodeExtraQueryParams - A flag to choose whether to encode extra query parameters in the request URL. Defaults to false.
- * @public
- */
-export type NodeAuthOptions = {
-    clientId: string;
-    authority?: string;
-    clientSecret?: string;
-    clientAssertion?: string | ClientAssertionCallback;
-    clientCertificate?: {
-        /**
-         * @deprecated Use thumbprintSha2 property instead. Thumbprint needs to be computed with SHA-256 algorithm.
-         * SHA-1 is only needed for backwards compatibility with older versions of ADFS.
-         */
-        thumbprint?: string;
-        thumbprintSha256?: string;
-        privateKey: string;
-        x5c?: string;
-    };
-    knownAuthorities?: Array<string>;
-    cloudDiscoveryMetadata?: string;
-    authorityMetadata?: string;
-    clientCapabilities?: Array<string>;
-    protocolMode?: ProtocolMode;
-    azureCloudOptions?: AzureCloudOptions;
-    skipAuthorityMetadataCache?: boolean;
-    /**
-     * @deprecated This flag is deprecated and will be removed in the next major version where all extra query params will be encoded by default.
-     */
-    encodeExtraQueryParams?: boolean;
-};
-
-/**
- * Use this to configure the below cache configuration options:
- *
- * - cachePlugin   - Plugin for reading and writing token cache to disk.
- * @public
- */
-export type CacheOptions = {
-    cachePlugin?: ICachePlugin;
-    /**
-     * @deprecated claims-based-caching functionality will be removed in the next version of MSALJS
-     */
-    claimsBasedCachingEnabled?: boolean;
-};
-
-/**
- * Use this to configure the below broker options:
- * - nativeBrokerPlugin - Native broker implementation (should be imported from msal-node-extensions)
- *
- * Note: These options are only available for PublicClientApplications using the Authorization Code Flow
- * @public
- */
-export type BrokerOptions = {
-    nativeBrokerPlugin?: INativeBrokerPlugin;
-};
-
-/**
- * Type for configuring logger and http client options
- *
- * - logger                       - Used to initialize the Logger object; TODO: Expand on logger details or link to the documentation on logger
- * - networkClient                - Http client used for all http get and post calls. Defaults to using MSAL's default http client.
- * @public
- */
-export type NodeSystemOptions = {
-    loggerOptions?: LoggerOptions;
-    networkClient?: INetworkModule;
-    proxyUrl?: string;
-    customAgentOptions?: http.AgentOptions | https.AgentOptions;
-    disableInternalRetries?: boolean;
-};
-
-/** @public */
-export type NodeTelemetryOptions = {
-    application?: ApplicationTelemetry;
-};
-
-/**
- * Use the configuration object to configure MSAL and initialize the client application object
- *
- * - auth: this is where you configure auth elements like clientID, authority used for authenticating against the Microsoft Identity Platform
- * - broker: this is where you configure broker options
- * - cache: this is where you configure cache location
- * - system: this is where you can configure the network client, logger
- * - telemetry: this is where you can configure telemetry options
- * @public
- */
-export type Configuration = {
-    auth: NodeAuthOptions;
-    broker?: BrokerOptions;
-    cache?: CacheOptions;
-    system?: NodeSystemOptions;
-    telemetry?: NodeTelemetryOptions;
-};
-
-/** @public */
-export type ManagedIdentityIdParams = {
-    userAssignedClientId?: string;
-    userAssignedResourceId?: string;
-    userAssignedObjectId?: string;
-};
-
-/** @public */
-export type ManagedIdentityConfiguration = {
-    clientCapabilities?: Array<string>;
-    managedIdentityIdParams?: ManagedIdentityIdParams;
-    system?: NodeSystemOptions;
-};
-
-const DEFAULT_AUTH_OPTIONS: Required<NodeAuthOptions> = {
-    clientId: Constants.EMPTY_STRING,
-    authority: Constants.DEFAULT_AUTHORITY,
-    clientSecret: Constants.EMPTY_STRING,
-    clientAssertion: Constants.EMPTY_STRING,
-    clientCertificate: {
-        thumbprint: Constants.EMPTY_STRING,
-        thumbprintSha256: Constants.EMPTY_STRING,
-        privateKey: Constants.EMPTY_STRING,
-        x5c: Constants.EMPTY_STRING,
-    },
-    knownAuthorities: [],
-    cloudDiscoveryMetadata: Constants.EMPTY_STRING,
-    authorityMetadata: Constants.EMPTY_STRING,
-    clientCapabilities: [],
-    protocolMode: ProtocolMode.AAD,
-    azureCloudOptions: {
-        azureCloudInstance: AzureCloudInstance.None,
-        tenant: Constants.EMPTY_STRING,
-    },
-    skipAuthorityMetadataCache: false,
-    encodeExtraQueryParams: false,
-};
-
-const DEFAULT_CACHE_OPTIONS: CacheOptions = {
-    claimsBasedCachingEnabled: false,
-};
-
-const DEFAULT_LOGGER_OPTIONS: LoggerOptions = {
-    loggerCallback: (): void => {
-        // allow users to not set logger call back
-    },
-    piiLoggingEnabled: false,
-    logLevel: LogLevel.Info,
-};
-
-const DEFAULT_SYSTEM_OPTIONS: Required<NodeSystemOptions> = {
-    loggerOptions: DEFAULT_LOGGER_OPTIONS,
-    networkClient: new HttpClient(),
-    proxyUrl: Constants.EMPTY_STRING,
-    customAgentOptions: {} as http.AgentOptions | https.AgentOptions,
-    disableInternalRetries: false,
-};
-
-const DEFAULT_TELEMETRY_OPTIONS: Required<NodeTelemetryOptions> = {
-    application: {
-        appName: Constants.EMPTY_STRING,
-        appVersion: Constants.EMPTY_STRING,
-    },
-};
-
-/** @internal */
-export type NodeConfiguration = {
-    auth: Required<NodeAuthOptions>;
-    broker: BrokerOptions;
-    cache: CacheOptions;
-    system: Required<NodeSystemOptions>;
-    telemetry: Required<NodeTelemetryOptions>;
-};
-
-/**
- * Sets the default options when not explicitly configured from app developer
- *
- * @param auth - Authentication options
- * @param cache - Cache options
- * @param system - System options
- * @param telemetry - Telemetry options
- *
- * @returns Configuration
- * @internal
- */
-export function buildAppConfiguration({
-    auth,
-    broker,
-    cache,
-    system,
-    telemetry,
-}: Configuration): NodeConfiguration {
-    const systemOptions: Required<NodeSystemOptions> = {
-        ...DEFAULT_SYSTEM_OPTIONS,
-        networkClient: new HttpClient(
-            system?.proxyUrl,
-            system?.customAgentOptions as http.AgentOptions | https.AgentOptions
-        ),
-        loggerOptions: system?.loggerOptions || DEFAULT_LOGGER_OPTIONS,
-        disableInternalRetries: system?.disableInternalRetries || false,
-    };
-
-    // if client certificate was provided, ensure that at least one of the SHA-1 or SHA-256 thumbprints were provided
-    if (
-        !!auth.clientCertificate &&
-        !!!auth.clientCertificate.thumbprint &&
-        !!!auth.clientCertificate.thumbprintSha256
-    ) {
-        throw NodeAuthError.createStateNotFoundError();
-    }
-
-    return {
-        auth: { ...DEFAULT_AUTH_OPTIONS, ...auth },
-        broker: { ...broker },
-        cache: { ...DEFAULT_CACHE_OPTIONS, ...cache },
-        system: { ...systemOptions, ...system },
-        telemetry: { ...DEFAULT_TELEMETRY_OPTIONS, ...telemetry },
-    };
-}
-
-/** @internal */
-export type ManagedIdentityNodeConfiguration = {
-    clientCapabilities?: Array<string>;
-    disableInternalRetries: boolean;
-    managedIdentityId: ManagedIdentityId;
-    system: Required<
-        Pick<NodeSystemOptions, "loggerOptions" | "networkClient">
-    >;
-};
-
-export function buildManagedIdentityConfiguration({
-    clientCapabilities,
-    managedIdentityIdParams,
-    system,
-}: ManagedIdentityConfiguration): ManagedIdentityNodeConfiguration {
-    const managedIdentityId: ManagedIdentityId = new ManagedIdentityId(
-        managedIdentityIdParams
-    );
-
-    const loggerOptions: LoggerOptions =
-        system?.loggerOptions || DEFAULT_LOGGER_OPTIONS;
-
-    let networkClient: INetworkModule;
-    // use developer provided network client if passed in
-    if (system?.networkClient) {
-        networkClient = system.networkClient;
-        // otherwise, create a new one
-    } else {
-        networkClient = new HttpClient(
-            system?.proxyUrl,
-            system?.customAgentOptions as http.AgentOptions | https.AgentOptions
-        );
-    }
-
-    return {
-        clientCapabilities: clientCapabilities || [],
-        managedIdentityId: managedIdentityId,
-        system: {
-            loggerOptions,
-            networkClient,
-        },
-        disableInternalRetries: system?.disableInternalRetries || false,
-    };
-}