@beam-network/sdk 0.5.15 → 0.5.17-dev.0

package/dist/huggingface.js

@@ -0,0 +1,298 @@
+export const HUGGINGFACE_DEFAULT_ENDPOINT = "https://huggingface.co";
+export const HUGGINGFACE_DEFAULT_REVISION = "main";
+export const HUGGINGFACE_DEFAULT_REPO_TYPE = "model";
+const LFS_CONTENT_TYPE = "application/vnd.git-lfs+json";
+/** Mirrors `constants.REPO_TYPES_URL_PREFIXES`; models carry no prefix. */
+const REPO_TYPE_URL_PREFIXES = {
+    model: "",
+    dataset: "datasets/",
+    space: "spaces/",
+    kernel: "kernels/",
+    bucket: "buckets/"
+};
+export function huggingFaceEndpoint(config) {
+    return (config.endpoint ?? HUGGINGFACE_DEFAULT_ENDPOINT).replace(/\/+$/, "");
+}
+export function huggingFaceRepoType(config) {
+    return config.repo_type ?? HUGGINGFACE_DEFAULT_REPO_TYPE;
+}
+export function huggingFaceRevision(config) {
+    return config.revision ?? HUGGINGFACE_DEFAULT_REVISION;
+}
+/**
+ * `{endpoint}/{prefix}{repo_id}/resolve/{revision}/{path}`, as built by `hf_hub_url`.
+ *
+ * Buckets are unversioned and take no revision segment, and the Hub escapes their whole key
+ * as one component — see `HfApi.get_bucket_file_metadata`.
+ */
+export function huggingFaceResolveUrl(config) {
+    const repoType = huggingFaceRepoType(config);
+    const prefix = REPO_TYPE_URL_PREFIXES[repoType];
+    if (repoType === "bucket") {
+        return `${huggingFaceEndpoint(config)}/${prefix}${config.repo_id}/resolve/${encodeURIComponent(config.path)}`;
+    }
+    const revision = encodeURIComponent(huggingFaceRevision(config));
+    return `${huggingFaceEndpoint(config)}/${prefix}${config.repo_id}/resolve/${revision}/${encodePath(config.path)}`;
+}
+/** `{endpoint}/api/{repo_type}s/{repo_id}`. */
+export function huggingFaceApiBase(config) {
+    return `${huggingFaceEndpoint(config)}/api/${huggingFaceRepoType(config)}s/${config.repo_id}`;
+}
+/** `{endpoint}/{prefix}{repo_id}.git/info/lfs/objects/batch`. */
+export function huggingFaceLfsBatchUrl(config) {
+    const prefix = REPO_TYPE_URL_PREFIXES[huggingFaceRepoType(config)];
+    return `${huggingFaceEndpoint(config)}/${prefix}${config.repo_id}.git/info/lfs/objects/batch`;
+}
+/**
+ * HEAD the resolve URL and require the Hub to redirect to its CDN. The redirect target is
+ * presigned and carries no credential, so it is the only form of this URL that may be handed
+ * to BeamCore and the workers.
+ */
+export async function huggingFaceFileMetadata(fetchImpl, config) {
+    const resolveUrl = huggingFaceResolveUrl(config);
+    const response = await fetchImpl(resolveUrl, {
+        method: "HEAD",
+        redirect: "manual",
+        headers: {
+            Authorization: `Bearer ${config.token}`,
+            // Compression would report a transformed length instead of the real object size.
+            "Accept-Encoding": "identity"
+        }
+    });
+    if (response.status >= 400) {
+        throw new Error(`Hugging Face file lookup failed status=${response.status} for ${describe(config)}`);
+    }
+    const location = response.headers.get("location");
+    if (!location || sameHost(resolveUrl, location)) {
+        throw new Error(`Hugging Face did not redirect ${describe(config)} to a presigned CDN URL. `
+            + "Beam reads this file over plain HTTP without forwarding your token, and the Hub only "
+            + "redirects for large-file (LFS or Xet) content. A small regular file is served inline "
+            + "from the Hub instead and cannot be transferred.");
+    }
+    const linkedSize = response.headers.get("x-linked-size");
+    const size = Number(linkedSize ?? response.headers.get("content-length") ?? Number.NaN);
+    if (!Number.isFinite(size) || size <= 0) {
+        throw new Error(`Hugging Face did not report a size for ${describe(config)}`);
+    }
+    return {
+        url: location,
+        size,
+        etag: normalizeEtag(response.headers.get("x-linked-etag") ?? response.headers.get("etag")),
+        commitHash: response.headers.get("x-repo-commit") ?? undefined
+    };
+}
+/**
+ * Ask the Hub whether a path is stored as an LFS blob or as a regular git blob.
+ * `sample` is the base64 of the first 512 bytes, exactly as `_fetch_upload_modes` sends it.
+ */
+export async function huggingFacePreupload(fetchImpl, config, input) {
+    const url = new URL(`${huggingFaceApiBase(config)}/preupload/${encodeURIComponent(huggingFaceRevision(config))}`);
+    if (config.create_pr)
+        url.searchParams.set("create_pr", "1");
+    const response = await fetchImpl(url, {
+        method: "POST",
+        headers: jsonHeaders(config),
+        body: JSON.stringify({ files: [{ path: config.path, sample: input.sample, size: input.size }] })
+    });
+    const payload = await readJson(response, "preupload", config);
+    const file = Array.isArray(payload.files) ? payload.files[0] : undefined;
+    if (!file || (file.uploadMode !== "lfs" && file.uploadMode !== "regular")) {
+        throw new Error(`Hugging Face preupload returned a malformed response for ${describe(config)}`);
+    }
+    return {
+        uploadMode: file.uploadMode,
+        shouldIgnore: Boolean(file.shouldIgnore),
+        oid: typeof file.oid === "string" ? file.oid : undefined
+    };
+}
+/**
+ * Request upload instructions for one object. The Hub answers with either a single-part PUT
+ * target or a completion endpoint plus one presigned PUT URL per part.
+ */
+export async function huggingFaceLfsBatch(fetchImpl, config, input) {
+    const response = await fetchImpl(huggingFaceLfsBatchUrl(config), {
+        method: "POST",
+        headers: {
+            Authorization: `Bearer ${config.token}`,
+            Accept: LFS_CONTENT_TYPE,
+            "Content-Type": LFS_CONTENT_TYPE
+        },
+        body: JSON.stringify({
+            operation: "upload",
+            transfers: ["basic", "multipart"],
+            hash_algo: "sha256",
+            ref: { name: huggingFaceRevision(config) },
+            objects: [{ oid: input.oid, size: input.size }]
+        })
+    });
+    const payload = await readJson(response, "LFS batch", config);
+    const object = Array.isArray(payload.objects) ? payload.objects[0] : undefined;
+    if (!object || typeof object.oid !== "string") {
+        throw new Error(`Hugging Face LFS batch returned a malformed response for ${describe(config)}`);
+    }
+    if (object.error) {
+        throw new Error(`Hugging Face LFS batch rejected ${describe(config)}: ${object.error.message ?? "unknown error"}`);
+    }
+    const uploadAction = object.actions?.upload;
+    if (!uploadAction) {
+        // No actions means the Hub already stores this content; only the commit is left to do.
+        return { oid: object.oid, size: input.size };
+    }
+    if (typeof uploadAction.href !== "string") {
+        throw new Error(`Hugging Face LFS batch returned no upload href for ${describe(config)}`);
+    }
+    const header = uploadAction.header ?? {};
+    const rawChunkSize = header.chunk_size;
+    const chunkSize = rawChunkSize === undefined ? undefined : Number(rawChunkSize);
+    if (chunkSize !== undefined && (!Number.isInteger(chunkSize) || chunkSize <= 0)) {
+        throw new Error(`Hugging Face LFS batch returned a malformed chunk_size '${rawChunkSize}' for ${describe(config)}`);
+    }
+    const partUrls = Object.entries(header)
+        .filter(([key]) => /^\d+$/.test(key))
+        .sort(([left], [right]) => Number(left) - Number(right))
+        .map(([, value]) => value);
+    if (chunkSize !== undefined && partUrls.length !== Math.ceil(input.size / chunkSize)) {
+        throw new Error(`Hugging Face returned ${partUrls.length} part URLs for ${describe(config)}, `
+            + `expected ${Math.ceil(input.size / chunkSize)} at chunk_size ${chunkSize}`);
+    }
+    return {
+        oid: object.oid,
+        size: input.size,
+        upload: { href: uploadAction.href, chunkSize, partUrls },
+        verifyHref: typeof object.actions?.verify?.href === "string" ? object.actions.verify.href : undefined
+    };
+}
+/** Close a multipart LFS upload: `{oid, parts:[{partNumber, etag}]}` to the completion href. */
+export async function huggingFaceCompleteLfsUpload(fetchImpl, config, input) {
+    const response = await fetchImpl(input.href, {
+        method: "POST",
+        headers: { Accept: LFS_CONTENT_TYPE, "Content-Type": LFS_CONTENT_TYPE },
+        body: JSON.stringify({
+            oid: input.oid,
+            parts: input.etags.map((etag, index) => ({ partNumber: index + 1, etag }))
+        })
+    });
+    await assertOk(response, "LFS completion", config);
+}
+/** Optional server-side check that the object landed intact. */
+export async function huggingFaceVerifyLfsUpload(fetchImpl, config, input) {
+    const response = await fetchImpl(input.href, {
+        method: "POST",
+        headers: jsonHeaders(config),
+        body: JSON.stringify({ oid: input.oid, size: input.size })
+    });
+    await assertOk(response, "LFS verify", config);
+}
+/** Publish the uploaded blob as a commit. The body is NDJSON: a header line then one file line. */
+export async function huggingFaceCommit(fetchImpl, config, input) {
+    const url = new URL(`${huggingFaceApiBase(config)}/commit/${encodeURIComponent(huggingFaceRevision(config))}`);
+    if (config.create_pr)
+        url.searchParams.set("create_pr", "1");
+    const lines = [
+        {
+            key: "header",
+            value: {
+                summary: config.commit_message ?? `Upload ${config.path} with Beam`,
+                description: config.commit_description ?? ""
+            }
+        },
+        {
+            key: "lfsFile",
+            value: { path: config.path, algo: "sha256", oid: input.oid, size: input.size }
+        }
+    ];
+    const response = await fetchImpl(url, {
+        method: "POST",
+        headers: { Authorization: `Bearer ${config.token}`, "Content-Type": "application/x-ndjson" },
+        body: lines.map((line) => JSON.stringify(line)).join("\n")
+    });
+    const payload = await readJson(response, "commit", config);
+    return {
+        commitOid: typeof payload.commitOid === "string" ? payload.commitOid : undefined,
+        pullRequestUrl: typeof payload.pullRequestUrl === "string" ? payload.pullRequestUrl : undefined
+    };
+}
+/** Read the first `length` bytes of a URL and return them base64-encoded, for `preupload`. */
+export async function readSourceSample(fetchImpl, url, length = 512) {
+    const response = await fetchImpl(url, { headers: { Range: `bytes=0-${length - 1}` } });
+    if (!response.ok) {
+        throw new Error(`source sample read failed status=${response.status}`);
+    }
+    return base64(new Uint8Array(await response.arrayBuffer()));
+}
+/**
+ * Stream a URL once and return the sha256 of the whole body plus, when `partSize` is given,
+ * the hex MD5 of every part. The Hub will not issue upload URLs without the sha256, and the
+ * per-part MD5 is the ETag the completion payload has to quote.
+ */
+export async function hashSourceStream(fetchImpl, url, options = {}) {
+    const { createHash } = await import("node:crypto");
+    const response = await fetchImpl(url);
+    if (!response.ok || !response.body) {
+        throw new Error(`source hash read failed status=${response.status}`);
+    }
+    const whole = options.sha256 === false ? null : createHash("sha256");
+    const partSize = options.partSize;
+    const partEtags = [];
+    let part = partSize ? createHash("md5") : null;
+    let partBytes = 0;
+    for await (const rawChunk of response.body) {
+        let chunk = rawChunk;
+        whole?.update(chunk);
+        while (partSize && part && chunk.length > 0) {
+            const room = partSize - partBytes;
+            if (chunk.length < room) {
+                part.update(chunk);
+                partBytes += chunk.length;
+                break;
+            }
+            part.update(chunk.subarray(0, room));
+            partEtags.push(part.digest("hex"));
+            part = createHash("md5");
+            partBytes = 0;
+            chunk = chunk.subarray(room);
+        }
+    }
+    if (partSize && part && partBytes > 0) {
+        partEtags.push(part.digest("hex"));
+    }
+    return { sha256: whole?.digest("hex"), partEtags };
+}
+function encodePath(path) {
+    return path.split("/").map(encodeURIComponent).join("/");
+}
+function sameHost(left, right) {
+    try {
+        return new URL(left).host === new URL(right, left).host;
+    }
+    catch {
+        return true;
+    }
+}
+function normalizeEtag(value) {
+    if (!value)
+        return undefined;
+    return value.replace(/^W\//, "").replace(/^"|"$/g, "");
+}
+function jsonHeaders(config) {
+    return { Authorization: `Bearer ${config.token}`, "Content-Type": "application/json" };
+}
+async function readJson(response, step, config) {
+    await assertOk(response, step, config);
+    return (await response.json());
+}
+async function assertOk(response, step, config) {
+    if (response.ok)
+        return;
+    const detail = (await response.text().catch(() => "")).slice(0, 512);
+    throw new Error(`Hugging Face ${step} failed status=${response.status} for ${describe(config)}${detail ? `: ${detail}` : ""}`);
+}
+function base64(bytes) {
+    let binary = "";
+    for (const byte of bytes)
+        binary += String.fromCharCode(byte);
+    return typeof btoa === "function" ? btoa(binary) : Buffer.from(bytes).toString("base64");
+}
+export function describe(config) {
+    return `${huggingFaceRepoType(config)} ${config.repo_id}@${huggingFaceRevision(config)}/${config.path}`;
+}

package/dist/index.d.ts

@@ -1,3 +1,4 @@
 export * from "./client.js";
 export * from "./models.js";
 export * from "./provider-signing.js";
+export * from "./multipart-limits.js";

package/dist/index.js

@@ -1,3 +1,4 @@
 export * from "./client.js";
 export * from "./models.js";
 export * from "./provider-signing.js";
+export * from "./multipart-limits.js";

package/dist/models.d.ts

@@ -182,6 +182,8 @@ export interface ProviderTransferResumeInput {
     testMode?: boolean;
     expiresIn?: number;
     signedUrlFlow?: SignedUrlFlow;
+    /** Requested plan chunk size. BeamCore may raise it; the response carries the effective value. */
+    chunkSize?: number;
 }
 export interface TransferTerminalEvent {
     schema_version: "transfer-client-control/v6";
@@ -237,13 +239,41 @@ export interface HippiusProviderConfig {
     api_token: string;
     base_url?: string;
 }
-export type ProviderConfig = S3ProviderConfig | R2ProviderConfig | S3CompatibleProviderConfig | HippiusProviderConfig;
+export type HuggingFaceRepoType = "model" | "dataset" | "space" | "kernel" | "bucket";
+export interface HuggingFaceProviderConfig {
+    provider: "huggingface";
+    id?: string;
+    /** Namespace and repo or bucket name separated by a slash, for example `org/dataset`. */
+    repo_id: string;
+    /** Path of the file inside the repo. */
+    path: string;
+    /** Defaults to `model`. */
+    repo_type?: HuggingFaceRepoType;
+    /** Branch, tag or commit. Defaults to `main`. Buckets are unversioned and ignore it. */
+    revision?: string;
+    token: string;
+    /** Hub endpoint. Defaults to `https://huggingface.co`. */
+    endpoint?: string;
+    /** Destination only. Commit summary for the upload. */
+    commit_message?: string;
+    /** Destination only. Commit description for the upload. */
+    commit_description?: string;
+    /** Destination only. Open the upload as a pull request instead of committing to `revision`. */
+    create_pr?: boolean;
+    /**
+     * Destination only. The Hub issues LFS upload URLs only for a known sha256, so the SDK
+     * must read every source byte once to hash it. Opt in explicitly.
+     */
+    allow_source_rehash?: boolean;
+}
+export type ProviderConfig = S3ProviderConfig | R2ProviderConfig | S3CompatibleProviderConfig | HippiusProviderConfig | HuggingFaceProviderConfig;
 export type ProviderSourceConfig = ProviderConfig;
 export type ProviderDestinationConfig = ProviderConfig;
 export type S3ProviderConfigInput = Omit<S3ProviderConfig, "provider">;
 export type R2ProviderConfigInput = Omit<R2ProviderConfig, "provider">;
 export type S3CompatibleProviderConfigInput = Omit<S3CompatibleProviderConfig, "driver">;
 export type HippiusProviderConfigInput = Omit<HippiusProviderConfig, "provider">;
+export type HuggingFaceProviderConfigInput = Omit<HuggingFaceProviderConfig, "provider">;
 export declare const S3ProviderConfig: Readonly<{
     create(input: S3ProviderConfigInput): S3ProviderConfig;
 }>;
@@ -256,6 +286,9 @@ export declare const S3CompatibleProviderConfig: Readonly<{
 export declare const HippiusProviderConfig: Readonly<{
     create(input: HippiusProviderConfigInput): HippiusProviderConfig;
 }>;
+export declare const HuggingFaceProviderConfig: Readonly<{
+    create(input: HuggingFaceProviderConfigInput): HuggingFaceProviderConfig;
+}>;
 export interface ProviderTransferCreateInput {
     sources: ProviderSourceConfig[];
     destinations: ProviderDestinationConfig[];
@@ -271,12 +304,31 @@ export interface ProviderTransferCreateInput {
     distribute?: boolean;
     onBeforeTransferPrepare?: () => void | Promise<void>;
     onPrepared?: (prepared: TransferPrepareResponse) => void | Promise<void>;
+    /**
+     * Called after the SDK creates a multipart upload and before its signed
+     * routes are streamed. The payload contains durable identity only;
+     * credentials, headers, and signed URLs are never exposed.
+     */
+    onMultipartGroupReady?: (group: ProviderMultipartGroupIdentity) => void | Promise<void>;
     throwIfCancelled?: (transferId?: string) => void | Promise<void>;
     signedUrlFlow?: SignedUrlFlow;
     /** Stable caller identity used to derive the transfer and lifecycle request ids. */
     idempotencyKey?: string;
     /** Internal recovery generation; callers normally omit this. */
     routeGenerationId?: string;
+    /** Requested plan chunk size. BeamCore may raise it; the response carries the effective value. */
+    chunkSize?: number;
+}
+export interface ProviderMultipartGroupIdentity {
+    transferId: string;
+    multipartGroupId: string;
+    sourceId: string;
+    destinationId: string;
+    objectKey: string;
+    uploadId: string;
+    expectedObjectSize: number;
+    expectedPartCount: number;
+    expiresAt: string;
 }
 export interface PlanningHttpSource {
     source_id: string;

package/dist/models.js

@@ -38,6 +38,25 @@ export const HippiusProviderConfig = Object.freeze({
         return { provider: "hippius", ...input };
     }
 });
+const HUGGINGFACE_REPO_TYPES = [
+    "model",
+    "dataset",
+    "space",
+    "kernel",
+    "bucket"
+];
+export const HuggingFaceProviderConfig = Object.freeze({
+    create(input) {
+        requireFields("huggingface", input, ["repo_id", "path", "token"]);
+        if (input.repo_type !== undefined && !HUGGINGFACE_REPO_TYPES.includes(input.repo_type)) {
+            throw new Error(`huggingface config repo_type must be one of ${HUGGINGFACE_REPO_TYPES.join(", ")}.`);
+        }
+        if (!input.repo_id.includes("/")) {
+            throw new Error("huggingface config repo_id must be `namespace/name`.");
+        }
+        return { provider: "huggingface", ...input };
+    }
+});
 function requireFields(provider, input, fields) {
     for (const field of fields) {
         if (!hasText(input[field])) {

package/dist/nats-control.d.ts

@@ -1,8 +1,8 @@
 import { type ConnectionOptions } from "nats";
 import type { MultipartGroupManifest, SignedChunkRoute, TransferTerminalSignalWaiter } from "./models.js";
 export declare const TRANSFER_CLIENT_CONTROL_SCHEMA_VERSION = "transfer-client-control/v6";
-export declare const BEAM_DEFAULT_NATS_URL = "tls://nats.b1m.ai:4222";
-export declare const BEAM_DEFAULT_NATS_WS_URL = "wss://nats.b1m.ai:443";
+export declare const BEAM_DEFAULT_NATS_URL = "tls://orch-gateway.b1m.ai:4222";
+export declare const BEAM_DEFAULT_NATS_WS_URL = "wss://orch-gateway.b1m.ai:443";
 export declare const BEAM_DEFAULT_MAX_PAYLOAD_BYTES: number;
 export declare const BEAM_ROUTE_TARGET_PAYLOAD_BYTES: number;
 export declare const ROUTE_RECOVERY_SIGN_MESSAGE_TYPE: "transfer.route_recovery.sign";

package/dist/nats-control.js

@@ -1,8 +1,8 @@
 import { encode, decode } from "@msgpack/msgpack";
 import { connect } from "nats";
 export const TRANSFER_CLIENT_CONTROL_SCHEMA_VERSION = "transfer-client-control/v6";
-export const BEAM_DEFAULT_NATS_URL = "tls://nats.b1m.ai:4222";
-export const BEAM_DEFAULT_NATS_WS_URL = "wss://nats.b1m.ai:443";
+export const BEAM_DEFAULT_NATS_URL = "tls://orch-gateway.b1m.ai:4222";
+export const BEAM_DEFAULT_NATS_WS_URL = "wss://orch-gateway.b1m.ai:443";
 // NATS enforces max_payload per message. This guard splits signed-route control
 // messages before the broker rejects them; transfer bytes never flow through NATS.
 export const BEAM_DEFAULT_MAX_PAYLOAD_BYTES = 8 * 1024 * 1024;

package/dist/provider-signing.d.ts

@@ -1,4 +1,4 @@
-import type { ChunkDestinationSigningTarget, ChunkSigningPlanItem, PlanningHttpSource, PreparedDestination, PreparedHttpSource, ProviderDestinationConfig, ProviderSourceConfig, R2ProviderConfig, S3CompatibleProviderConfig, S3ProviderConfig, SignedChunkRoute } from "./models.js";
+import type { ChunkDestinationSigningTarget, ChunkSigningPlanItem, HuggingFaceProviderConfig, PlanningHttpSource, PreparedDestination, PreparedHttpSource, ProviderDestinationConfig, ProviderSourceConfig, R2ProviderConfig, S3CompatibleProviderConfig, S3ProviderConfig, SignedChunkRoute } from "./models.js";
 export type AnyS3CompatibleProviderConfig = S3ProviderConfig | R2ProviderConfig | S3CompatibleProviderConfig;
 export declare function nowIso(): string;
 export declare function expiresAtIso(expiresIn: number): string;
@@ -27,6 +27,30 @@ export declare function signListMultipartUpload(destination: ProviderDestination
     partNumberMarker?: number;
 }): Promise<string>;
 export declare function abortMultipartUpload(destination: ProviderDestinationConfig, objectKey: string, uploadId: string): Promise<void>;
+/** Provider metadata only. These operations never read or proxy object bytes. */
+export declare function listMultipartParts(destination: ProviderDestinationConfig, objectKey: string, uploadId: string): Promise<{
+    partNumber: number;
+    etag: string;
+    size: number;
+}[]>;
+export declare function completeMultipartUpload(input: {
+    destination: ProviderDestinationConfig;
+    objectKey: string;
+    uploadId: string;
+    parts: {
+        partNumber: number;
+        etag: string;
+    }[];
+}): Promise<{
+    etag: string | undefined;
+    versionId: string | undefined;
+}>;
+export declare function inspectDestinationObject(destination: ProviderDestinationConfig, objectKey: string): Promise<{
+    size: number | undefined;
+    etag: string | undefined;
+    versionId: string | undefined;
+    metadata: Record<string, string>;
+}>;
 export declare function signDestinationRoute(input: {
     chunk: ChunkSigningPlanItem;
     target: ChunkDestinationSigningTarget;
@@ -45,10 +69,14 @@ export declare function signDestinationRoute(input: {
     maxPartNumber?: number;
     finalObjectMetadata?: Record<string, string>;
     multipartGroupId?: string;
+    /** Pre-issued destination URL, used by providers that sign their own upload targets. */
+    destUrl?: string;
     fetchImpl?: typeof fetch;
 }): Promise<SignedChunkRoute>;
 export declare function signSourceReadRange(input: {
     source: ProviderSourceConfig;
+    ifMatch?: string;
+    versionId?: string;
     offset: number;
     length: number;
     expiresIn: number;
@@ -68,7 +96,17 @@ export declare function signDestinationReadRange(input: {
     url: string;
     headers: Record<string, string>;
 }>;
+export declare function signDestinationUrl(input: {
+    contentMd5?: string;
+    destination: ProviderDestinationConfig;
+    objectKey: string;
+    uploadId?: string;
+    partNumber?: number;
+    expiresIn: number;
+    fetchImpl?: typeof fetch;
+}): Promise<string>;
 export declare function isS3CompatibleProvider(config: ProviderSourceConfig | ProviderDestinationConfig): config is AnyS3CompatibleProviderConfig;
 export declare function s3CompatibleEndpoint(source: AnyS3CompatibleProviderConfig): string | undefined;
 export declare function s3CompatibleRegion(source: AnyS3CompatibleProviderConfig): string;
 export declare function s3CompatibleForcePathStyle(source: AnyS3CompatibleProviderConfig, endpoint?: string | undefined): boolean | undefined;
+export declare function isHuggingFaceProvider(config: ProviderSourceConfig | ProviderDestinationConfig): config is HuggingFaceProviderConfig;