@databricks/sdk-clusterlibraries 0.0.0-dev → 0.1.0-dev.2

package/src/v2/client.ts

@@ -0,0 +1,217 @@
+// Code generated from API definition by Databricks SDK Generator. DO NOT EDIT.
+
+import {VERSION as AUTH_VERSION} from '@databricks/sdk-auth';
+import {createDefault} from '@databricks/sdk-core/clientinfo';
+import type {Logger} from '@databricks/sdk-core/logger';
+import {NoOpLogger} from '@databricks/sdk-core/logger';
+import type {CallOptions} from '@databricks/sdk-options/call';
+import type {ClientOptions} from '@databricks/sdk-options/client';
+import type {HttpClient} from '@databricks/sdk-core/http';
+import {newHttpClient} from './transport';
+import {
+  buildHttpRequest,
+  executeCall,
+  executeHttpCall,
+  marshalRequest,
+  parseResponse,
+} from './utils';
+import pkgJson from '../../package.json' with {type: 'json'};
+import type {
+  ClusterLibraryStatuses,
+  ClusterStatusRequest,
+  InstallLibrariesRequest,
+  InstallLibrariesRequest_Response,
+  ListAllClusterLibraryStatusesRequest,
+  ListAllClusterLibraryStatusesRequest_Response,
+  UninstallLibrariesRequest,
+  UninstallLibrariesRequest_Response,
+} from './model';
+import {
+  marshalInstallLibrariesRequestSchema,
+  marshalUninstallLibrariesRequestSchema,
+  unmarshalClusterLibraryStatusesSchema,
+  unmarshalInstallLibrariesRequest_ResponseSchema,
+  unmarshalListAllClusterLibraryStatusesRequest_ResponseSchema,
+  unmarshalUninstallLibrariesRequest_ResponseSchema,
+} from './model';
+
+// Package identity segment for this client to be used in the User-Agent header.
+const PACKAGE_SEGMENT = {
+  key: 'sdk-js-' + pkgJson.name.replace(/^@[^/]+\/sdk-/, ''),
+  value: pkgJson.version,
+};
+
+export class ClusterLibrariesClient {
+  private readonly host: string;
+  // Workspace ID used to route workspace-level calls on unified hosts (SPOG).
+  // When set, workspace-level methods send X-Databricks-Org-Id on every
+  // request.
+  private readonly workspaceId: string | undefined;
+  private readonly httpClient: HttpClient;
+  private readonly logger: Logger;
+  // User-Agent header value. Composed once at construction from
+  // createDefault() merged with this package's identity and the active
+  // credential's name.
+  private readonly userAgent: string;
+
+  constructor(options: ClientOptions) {
+    if (options.host === undefined) {
+      throw new Error('Host is required.');
+    }
+    this.host = options.host.replace(/\/$/, '');
+    this.workspaceId = options.workspaceId;
+    this.logger = options.logger ?? new NoOpLogger();
+    const info = createDefault()
+      .with(PACKAGE_SEGMENT)
+      .with({key: 'sdk-js-auth', value: AUTH_VERSION})
+      .with({key: 'auth', value: options.credentials?.name() ?? 'default'});
+    this.userAgent = info.toString();
+    this.httpClient = newHttpClient(options);
+  }
+
+  /**
+   * Get the status of all libraries on all clusters. A status is returned for all libraries installed on this cluster
+   * via the API or the libraries UI.
+   */
+  async allClusterStatuses(
+    _req: ListAllClusterLibraryStatusesRequest,
+    options?: CallOptions
+  ): Promise<ListAllClusterLibraryStatusesRequest_Response> {
+    const url = `${this.host}/api/2.0/libraries/all-cluster-statuses`;
+    let resp: ListAllClusterLibraryStatusesRequest_Response | undefined;
+    const call = async (callSignal?: AbortSignal): Promise<void> => {
+      const headers = new Headers();
+      if (this.workspaceId !== undefined) {
+        headers.set('X-Databricks-Org-Id', this.workspaceId);
+      }
+      headers.set('User-Agent', this.userAgent);
+      const httpReq = buildHttpRequest('GET', url, headers, callSignal);
+      const respBody = await executeHttpCall({
+        request: httpReq,
+        httpClient: this.httpClient,
+        logger: this.logger,
+      });
+      resp = parseResponse(
+        respBody,
+        unmarshalListAllClusterLibraryStatusesRequest_ResponseSchema
+      );
+    };
+    await executeCall(call, options);
+    if (resp === undefined) {
+      throw new Error('operation completed without a result.');
+    }
+    return resp;
+  }
+
+  /**
+   * Get the status of libraries on a cluster. A status is returned for all libraries installed on this cluster via the API
+   * or the libraries UI.
+   * The order of returned libraries is as follows:
+   * 1. Libraries set to be installed on this cluster, in the order that the libraries were added
+   * to the cluster, are returned first.
+   * 2. Libraries that were previously requested to be installed on this cluster or,
+   * but are now marked for removal, in no particular order, are returned last.
+   */
+  async clusterStatus(
+    req: ClusterStatusRequest,
+    options?: CallOptions
+  ): Promise<ClusterLibraryStatuses> {
+    const url = `${this.host}/api/2.0/libraries/cluster-status`;
+    const params = new URLSearchParams();
+    if (req.clusterId !== undefined) {
+      params.append('cluster_id', req.clusterId);
+    }
+    const query = params.toString();
+    const fullUrl = query !== '' ? `${url}?${query}` : url;
+    let resp: ClusterLibraryStatuses | undefined;
+    const call = async (callSignal?: AbortSignal): Promise<void> => {
+      const headers = new Headers();
+      if (this.workspaceId !== undefined) {
+        headers.set('X-Databricks-Org-Id', this.workspaceId);
+      }
+      headers.set('User-Agent', this.userAgent);
+      const httpReq = buildHttpRequest('GET', fullUrl, headers, callSignal);
+      const respBody = await executeHttpCall({
+        request: httpReq,
+        httpClient: this.httpClient,
+        logger: this.logger,
+      });
+      resp = parseResponse(respBody, unmarshalClusterLibraryStatusesSchema);
+    };
+    await executeCall(call, options);
+    if (resp === undefined) {
+      throw new Error('operation completed without a result.');
+    }
+    return resp;
+  }
+
+  /**
+   * Add libraries to install on a cluster. The installation is asynchronous; it happens in
+   * the background after the completion of this request.
+   */
+  async installLibraries(
+    req: InstallLibrariesRequest,
+    options?: CallOptions
+  ): Promise<InstallLibrariesRequest_Response> {
+    const url = `${this.host}/api/2.0/libraries/install`;
+    const body = marshalRequest(req, marshalInstallLibrariesRequestSchema);
+    let resp: InstallLibrariesRequest_Response | undefined;
+    const call = async (callSignal?: AbortSignal): Promise<void> => {
+      const headers = new Headers({'Content-Type': 'application/json'});
+      if (this.workspaceId !== undefined) {
+        headers.set('X-Databricks-Org-Id', this.workspaceId);
+      }
+      headers.set('User-Agent', this.userAgent);
+      const httpReq = buildHttpRequest('POST', url, headers, callSignal, body);
+      const respBody = await executeHttpCall({
+        request: httpReq,
+        httpClient: this.httpClient,
+        logger: this.logger,
+      });
+      resp = parseResponse(
+        respBody,
+        unmarshalInstallLibrariesRequest_ResponseSchema
+      );
+    };
+    await executeCall(call, options);
+    if (resp === undefined) {
+      throw new Error('operation completed without a result.');
+    }
+    return resp;
+  }
+
+  /**
+   * Set libraries to uninstall from a cluster. The libraries won't be uninstalled until
+   * the cluster is restarted. A request to uninstall a library that is not currently installed is ignored.
+   */
+  async uninstallLibraries(
+    req: UninstallLibrariesRequest,
+    options?: CallOptions
+  ): Promise<UninstallLibrariesRequest_Response> {
+    const url = `${this.host}/api/2.0/libraries/uninstall`;
+    const body = marshalRequest(req, marshalUninstallLibrariesRequestSchema);
+    let resp: UninstallLibrariesRequest_Response | undefined;
+    const call = async (callSignal?: AbortSignal): Promise<void> => {
+      const headers = new Headers({'Content-Type': 'application/json'});
+      if (this.workspaceId !== undefined) {
+        headers.set('X-Databricks-Org-Id', this.workspaceId);
+      }
+      headers.set('User-Agent', this.userAgent);
+      const httpReq = buildHttpRequest('POST', url, headers, callSignal, body);
+      const respBody = await executeHttpCall({
+        request: httpReq,
+        httpClient: this.httpClient,
+        logger: this.logger,
+      });
+      resp = parseResponse(
+        respBody,
+        unmarshalUninstallLibrariesRequest_ResponseSchema
+      );
+    };
+    await executeCall(call, options);
+    if (resp === undefined) {
+      throw new Error('operation completed without a result.');
+    }
+    return resp;
+  }
+}

package/src/v2/index.ts

@@ -0,0 +1,21 @@
+// Code generated from API definition by Databricks SDK Generator. DO NOT EDIT.
+
+export {ClusterLibrariesClient} from './client';
+
+export {LibraryInstallStatus} from './model';
+
+export type {
+  ClusterLibraryStatuses,
+  ClusterStatusRequest,
+  InstallLibrariesRequest,
+  InstallLibrariesRequest_Response,
+  Library,
+  LibraryFullStatus,
+  ListAllClusterLibraryStatusesRequest,
+  ListAllClusterLibraryStatusesRequest_Response,
+  MavenLibrary,
+  PythonPyPiLibrary,
+  RCranLibrary,
+  UninstallLibrariesRequest,
+  UninstallLibrariesRequest_Response,
+} from './model';

package/src/v2/model.ts

@@ -0,0 +1,383 @@
+// Code generated from API definition by Databricks SDK Generator. DO NOT EDIT.
+
+import {z} from 'zod';
+
+/** The status of a library on a specific cluster. */
+export enum LibraryInstallStatus {
+  /** No action has yet been taken to install the library. This state should be very short lived. */
+  PENDING = 'PENDING',
+  /**
+   * Metadata necessary to install the library is being retrieved from the provided repository.
+   *
+   * For jar and egg libraries, this step is a no-op.
+   */
+  RESOLVING = 'RESOLVING',
+  /**
+   * The library is actively being installed, either by adding resources to Spark or executing
+   * system commands inside the Spark nodes.
+   */
+  INSTALLING = 'INSTALLING',
+  /** The library has been successfully installed and can now be used. */
+  INSTALLED = 'INSTALLED',
+  /** Some step in installation failed. More information can be found in the `messages` field. */
+  FAILED = 'FAILED',
+  /**
+   * The library has been marked for removal. Currently, libraries can only be removed when clusters
+   * are restarted, so libraries that enter this state will remain until the cluster is restarted.
+   */
+  UNINSTALL_ON_RESTART = 'UNINSTALL_ON_RESTART',
+  /**
+   * Indicates that Library Manager decided to skip installation for this library.
+   * For example, shared libraries on DBR 7+ are skipped.
+   */
+  SKIPPED = 'SKIPPED',
+  /** Library installation is restored and can be used. */
+  RESTORED = 'RESTORED',
+}
+
+export interface ClusterLibraryStatuses {
+  /** Unique identifier for the cluster. */
+  clusterId?: string | undefined;
+  /** Status of all libraries on the cluster. */
+  libraryStatuses?: LibraryFullStatus[] | undefined;
+}
+
+export interface ClusterStatusRequest {
+  /** Unique identifier of the cluster whose status should be retrieved. */
+  clusterId?: string | undefined;
+}
+
+export interface InstallLibrariesRequest {
+  /** Unique identifier for the cluster on which to install these libraries. */
+  clusterId?: string | undefined;
+  /** The libraries to install. */
+  libraries?: Library[] | undefined;
+}
+
+// eslint-disable-next-line @typescript-eslint/naming-convention, @typescript-eslint/no-empty-object-type -- Proto-style nested message name.
+export interface InstallLibrariesRequest_Response {}
+
+export interface Library {
+  lib?:
+    | {
+        $case: 'jar';
+        /**
+         * URI of the JAR library to install. Supported URIs include Workspace paths, Unity Catalog Volumes paths, and S3 URIs.
+         * For example: `{ "jar": "/Workspace/path/to/library.jar" }`, `{ "jar" : "/Volumes/path/to/library.jar" }` or
+         * `{ "jar": "s3://my-bucket/library.jar" }`.
+         * If S3 is used, please make sure the cluster has read access on the library. You may need to
+         * launch the cluster with an IAM role to access the S3 URI.
+         */
+        jar: string;
+      }
+    | {
+        $case: 'egg';
+        /** Deprecated. URI of the egg library to install. Installing Python egg files is deprecated and is not supported in Databricks Runtime 14.0 and above. */
+        egg: string;
+      }
+    | {
+        $case: 'pypi';
+        /**
+         * Specification of a PyPi library to be installed. For example:
+         * `{ "package": "simplejson" }`
+         */
+        pypi: PythonPyPiLibrary;
+      }
+    | {
+        $case: 'maven';
+        /**
+         * Specification of a maven library to be installed. For example:
+         * `{ "coordinates": "org.jsoup:jsoup:1.7.2" }`
+         */
+        maven: MavenLibrary;
+      }
+    | {
+        $case: 'cran';
+        /** Specification of a CRAN library to be installed as part of the library */
+        cran: RCranLibrary;
+      }
+    | {
+        $case: 'whl';
+        /**
+         * URI of the wheel library to install. Supported URIs include Workspace paths, Unity Catalog Volumes paths, and S3 URIs.
+         * For example: `{ "whl": "/Workspace/path/to/library.whl" }`, `{ "whl" : "/Volumes/path/to/library.whl" }` or
+         * `{ "whl": "s3://my-bucket/library.whl" }`.
+         * If S3 is used, please make sure the cluster has read access on the library. You may need to
+         * launch the cluster with an IAM role to access the S3 URI.
+         */
+        whl: string;
+      }
+    | {
+        $case: 'requirements';
+        /**
+         * URI of the requirements.txt file to install. Only Workspace paths and Unity Catalog Volumes paths are supported.
+         * For example: `{ "requirements": "/Workspace/path/to/requirements.txt" }` or `{ "requirements" : "/Volumes/path/to/requirements.txt" }`
+         */
+        requirements: string;
+      }
+    | undefined;
+}
+
+/** The status of the library on a specific cluster. */
+export interface LibraryFullStatus {
+  /** Unique identifier for the library. */
+  library?: Library | undefined;
+  /** Status of installing the library on the cluster. */
+  status?: LibraryInstallStatus | undefined;
+  /** All the info and warning messages that have occurred so far for this library. */
+  messages?: string[] | undefined;
+  /** Whether the library was set to be installed on all clusters via the libraries UI. */
+  isLibraryForAllClusters?: boolean | undefined;
+}
+
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type
+export interface ListAllClusterLibraryStatusesRequest {}
+
+// eslint-disable-next-line @typescript-eslint/naming-convention -- Proto-style nested message name.
+export interface ListAllClusterLibraryStatusesRequest_Response {
+  /** A list of cluster statuses. */
+  statuses?: ClusterLibraryStatuses[] | undefined;
+}
+
+export interface MavenLibrary {
+  /** Gradle-style maven coordinates. For example: "org.jsoup:jsoup:1.7.2". */
+  coordinates?: string | undefined;
+  /**
+   * Maven repo to install the Maven package from. If omitted, both Maven Central Repository
+   * and Spark Packages are searched.
+   */
+  repo?: string | undefined;
+  /**
+   * List of dependences to exclude. For example: `["slf4j:slf4j", "*:hadoop-client"]`.
+   *
+   * Maven dependency exclusions:
+   * https://maven.apache.org/guides/introduction/introduction-to-optional-and-excludes-dependencies.html.
+   */
+  exclusions?: string[] | undefined;
+}
+
+export interface PythonPyPiLibrary {
+  /**
+   * The name of the pypi package to install. An optional exact version specification is also
+   * supported. Examples: "simplejson" and "simplejson==3.8.0".
+   */
+  package?: string | undefined;
+  /**
+   * The repository where the package can be found. If not specified, the default pip index is
+   * used.
+   */
+  repo?: string | undefined;
+}
+
+export interface RCranLibrary {
+  /** The name of the CRAN package to install. */
+  package?: string | undefined;
+  /** The repository where the package can be found. If not specified, the default CRAN repo is used. */
+  repo?: string | undefined;
+}
+
+export interface UninstallLibrariesRequest {
+  /** Unique identifier for the cluster on which to uninstall these libraries. */
+  clusterId?: string | undefined;
+  /** The libraries to uninstall. */
+  libraries?: Library[] | undefined;
+}
+
+// eslint-disable-next-line @typescript-eslint/naming-convention, @typescript-eslint/no-empty-object-type -- Proto-style nested message name.
+export interface UninstallLibrariesRequest_Response {}
+
+export const unmarshalClusterLibraryStatusesSchema: z.ZodType<ClusterLibraryStatuses> =
+  z
+    .object({
+      cluster_id: z.string().optional(),
+      library_statuses: z
+        .array(z.lazy(() => unmarshalLibraryFullStatusSchema))
+        .optional(),
+    })
+    .transform(d => ({
+      clusterId: d.cluster_id,
+      libraryStatuses: d.library_statuses,
+    }));
+
+// eslint-disable-next-line @typescript-eslint/naming-convention -- Proto-style nested message name.
+export const unmarshalInstallLibrariesRequest_ResponseSchema: z.ZodType<InstallLibrariesRequest_Response> =
+  z.object({});
+
+export const unmarshalLibrarySchema: z.ZodType<Library> = z
+  .object({
+    jar: z.string().optional(),
+    egg: z.string().optional(),
+    pypi: z.lazy(() => unmarshalPythonPyPiLibrarySchema).optional(),
+    maven: z.lazy(() => unmarshalMavenLibrarySchema).optional(),
+    cran: z.lazy(() => unmarshalRCranLibrarySchema).optional(),
+    whl: z.string().optional(),
+    requirements: z.string().optional(),
+  })
+  .transform(d => ({
+    lib:
+      d.jar !== undefined
+        ? {$case: 'jar' as const, jar: d.jar}
+        : d.egg !== undefined
+          ? {$case: 'egg' as const, egg: d.egg}
+          : d.pypi !== undefined
+            ? {$case: 'pypi' as const, pypi: d.pypi}
+            : d.maven !== undefined
+              ? {$case: 'maven' as const, maven: d.maven}
+              : d.cran !== undefined
+                ? {$case: 'cran' as const, cran: d.cran}
+                : d.whl !== undefined
+                  ? {$case: 'whl' as const, whl: d.whl}
+                  : d.requirements !== undefined
+                    ? {
+                        $case: 'requirements' as const,
+                        requirements: d.requirements,
+                      }
+                    : undefined,
+  }));
+
+export const unmarshalLibraryFullStatusSchema: z.ZodType<LibraryFullStatus> = z
+  .object({
+    library: z.lazy(() => unmarshalLibrarySchema).optional(),
+    status: z.enum(LibraryInstallStatus).optional(),
+    messages: z.array(z.string()).optional(),
+    is_library_for_all_clusters: z.boolean().optional(),
+  })
+  .transform(d => ({
+    library: d.library,
+    status: d.status,
+    messages: d.messages,
+    isLibraryForAllClusters: d.is_library_for_all_clusters,
+  }));
+
+// eslint-disable-next-line @typescript-eslint/naming-convention -- Proto-style nested message name.
+export const unmarshalListAllClusterLibraryStatusesRequest_ResponseSchema: z.ZodType<ListAllClusterLibraryStatusesRequest_Response> =
+  z
+    .object({
+      statuses: z
+        .array(z.lazy(() => unmarshalClusterLibraryStatusesSchema))
+        .optional(),
+    })
+    .transform(d => ({
+      statuses: d.statuses,
+    }));
+
+export const unmarshalMavenLibrarySchema: z.ZodType<MavenLibrary> = z
+  .object({
+    coordinates: z.string().optional(),
+    repo: z.string().optional(),
+    exclusions: z.array(z.string()).optional(),
+  })
+  .transform(d => ({
+    coordinates: d.coordinates,
+    repo: d.repo,
+    exclusions: d.exclusions,
+  }));
+
+export const unmarshalPythonPyPiLibrarySchema: z.ZodType<PythonPyPiLibrary> = z
+  .object({
+    package: z.string().optional(),
+    repo: z.string().optional(),
+  })
+  .transform(d => ({
+    package: d.package,
+    repo: d.repo,
+  }));
+
+export const unmarshalRCranLibrarySchema: z.ZodType<RCranLibrary> = z
+  .object({
+    package: z.string().optional(),
+    repo: z.string().optional(),
+  })
+  .transform(d => ({
+    package: d.package,
+    repo: d.repo,
+  }));
+
+// eslint-disable-next-line @typescript-eslint/naming-convention -- Proto-style nested message name.
+export const unmarshalUninstallLibrariesRequest_ResponseSchema: z.ZodType<UninstallLibrariesRequest_Response> =
+  z.object({});
+
+export const marshalInstallLibrariesRequestSchema: z.ZodType = z
+  .object({
+    clusterId: z.string().optional(),
+    libraries: z.array(z.lazy(() => marshalLibrarySchema)).optional(),
+  })
+  .transform(d => ({
+    cluster_id: d.clusterId,
+    libraries: d.libraries,
+  }));
+
+export const marshalLibrarySchema: z.ZodType = z
+  .object({
+    lib: z
+      .discriminatedUnion('$case', [
+        z.object({$case: z.literal('jar'), jar: z.string()}),
+        z.object({$case: z.literal('egg'), egg: z.string()}),
+        z.object({
+          $case: z.literal('pypi'),
+          pypi: z.lazy(() => marshalPythonPyPiLibrarySchema),
+        }),
+        z.object({
+          $case: z.literal('maven'),
+          maven: z.lazy(() => marshalMavenLibrarySchema),
+        }),
+        z.object({
+          $case: z.literal('cran'),
+          cran: z.lazy(() => marshalRCranLibrarySchema),
+        }),
+        z.object({$case: z.literal('whl'), whl: z.string()}),
+        z.object({$case: z.literal('requirements'), requirements: z.string()}),
+      ])
+      .optional(),
+  })
+  .transform(d => ({
+    ...(d.lib?.$case === 'jar' && {jar: d.lib.jar}),
+    ...(d.lib?.$case === 'egg' && {egg: d.lib.egg}),
+    ...(d.lib?.$case === 'pypi' && {pypi: d.lib.pypi}),
+    ...(d.lib?.$case === 'maven' && {maven: d.lib.maven}),
+    ...(d.lib?.$case === 'cran' && {cran: d.lib.cran}),
+    ...(d.lib?.$case === 'whl' && {whl: d.lib.whl}),
+    ...(d.lib?.$case === 'requirements' && {requirements: d.lib.requirements}),
+  }));
+
+export const marshalMavenLibrarySchema: z.ZodType = z
+  .object({
+    coordinates: z.string().optional(),
+    repo: z.string().optional(),
+    exclusions: z.array(z.string()).optional(),
+  })
+  .transform(d => ({
+    coordinates: d.coordinates,
+    repo: d.repo,
+    exclusions: d.exclusions,
+  }));
+
+export const marshalPythonPyPiLibrarySchema: z.ZodType = z
+  .object({
+    package: z.string().optional(),
+    repo: z.string().optional(),
+  })
+  .transform(d => ({
+    package: d.package,
+    repo: d.repo,
+  }));
+
+export const marshalRCranLibrarySchema: z.ZodType = z
+  .object({
+    package: z.string().optional(),
+    repo: z.string().optional(),
+  })
+  .transform(d => ({
+    package: d.package,
+    repo: d.repo,
+  }));
+
+export const marshalUninstallLibrariesRequestSchema: z.ZodType = z
+  .object({
+    clusterId: z.string().optional(),
+    libraries: z.array(z.lazy(() => marshalLibrarySchema)).optional(),
+  })
+  .transform(d => ({
+    cluster_id: d.clusterId,
+    libraries: d.libraries,
+  }));

package/src/v2/transport.ts

@@ -0,0 +1,73 @@
+// Code generated from API definition by Databricks SDK Generator. DO NOT EDIT.
+
+import type {Credentials} from '@databricks/sdk-auth';
+import {defaultCredentials} from '@databricks/sdk-auth/credentials';
+import type {
+  HttpClient,
+  HttpRequest,
+  HttpResponse,
+} from '@databricks/sdk-core/http';
+import {newFetchHttpClient} from '@databricks/sdk-core/http';
+import type {ClientOptions} from '@databricks/sdk-options/client';
+
+/** Creates a new HTTP client with the given options. */
+export function newHttpClient(options?: ClientOptions): HttpClient {
+  const opts = options ?? {};
+
+  // If an HTTP client is provided, use it as-is. Throw if other options are
+  // also set, since they would be silently ignored.
+  if (opts.httpClient !== undefined) {
+    if (opts.credentials !== undefined || opts.timeout !== undefined) {
+      throw new Error(
+        'httpClient cannot be combined with credentials or timeout'
+      );
+    }
+    return opts.httpClient;
+  }
+
+  const credentials = opts.credentials ?? defaultCredentials();
+
+  const base = newFetchHttpClient();
+  let client: HttpClient = new AuthHttpClient(base, credentials);
+
+  if (opts.timeout !== undefined) {
+    client = new TimeoutHttpClient(client, opts.timeout);
+  }
+
+  return client;
+}
+
+/** Wraps an HttpClient and adds authentication headers to requests. */
+class AuthHttpClient implements HttpClient {
+  constructor(
+    private readonly base: HttpClient,
+    private readonly credentials: Credentials
+  ) {}
+
+  async send(request: HttpRequest): Promise<HttpResponse> {
+    const authHeaders = await this.credentials.authHeaders();
+    // Do not modify the original request.
+    const headers = new Headers(request.headers);
+    for (const h of authHeaders) {
+      headers.set(h.key, h.value);
+    }
+    return this.base.send({...request, headers});
+  }
+}
+
+/** Wraps an HttpClient and applies a default timeout to requests. */
+class TimeoutHttpClient implements HttpClient {
+  constructor(
+    private readonly base: HttpClient,
+    private readonly timeout: number
+  ) {}
+
+  async send(request: HttpRequest): Promise<HttpResponse> {
+    const timeoutSignal = AbortSignal.timeout(this.timeout);
+    const signal =
+      request.signal !== undefined
+        ? AbortSignal.any([request.signal, timeoutSignal])
+        : timeoutSignal;
+    return this.base.send({...request, signal});
+  }
+}