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

package/dist/provider-signing.js

@@ -1,5 +1,6 @@
 import { AbortMultipartUploadCommand, CompleteMultipartUploadCommand, CreateMultipartUploadCommand, GetObjectCommand, HeadObjectCommand, ListPartsCommand, PutObjectCommand, S3Client, UploadPartCommand } from "@aws-sdk/client-s3";
 import { getSignedUrl } from "@aws-sdk/s3-request-presigner";
+import { huggingFaceEndpoint, huggingFaceFileMetadata, huggingFaceRepoType, huggingFaceRevision } from "./huggingface.js";
 export function nowIso() {
     return new Date().toISOString();
 }
@@ -47,6 +48,18 @@ export async function prepareProviderSource(source, options = {}) {
             metadata: { bucket: source.bucket, key: source.key, base_url: baseUrl }
         };
     }
+    if (isHuggingFaceProvider(source)) {
+        const metadata = await huggingFaceFileMetadata(options.fetchImpl ?? globalThis.fetch, source);
+        return {
+            source_id: source.id ?? `src_${index}`,
+            type: "http",
+            provider: "huggingface",
+            url: metadata.url,
+            size: metadata.size,
+            filename: filename(source.path),
+            metadata: huggingFaceMetadata(source, metadata.etag, metadata.commitHash)
+        };
+    }
     return unsupportedProviderConfig(source);
 }
 export async function prepareProviderSourceForPlan(source, options = {}) {
@@ -83,6 +96,17 @@ export async function prepareProviderSourceForPlan(source, options = {}) {
             metadata: { bucket: source.bucket, key: source.key, base_url: baseUrl }
         };
     }
+    if (isHuggingFaceProvider(source)) {
+        const metadata = await huggingFaceFileMetadata(options.fetchImpl ?? globalThis.fetch, source);
+        return {
+            source_id: source.id ?? `src_${index}`,
+            type: "http",
+            provider: "huggingface",
+            size: metadata.size,
+            filename: filename(source.path),
+            metadata: huggingFaceMetadata(source, metadata.etag, metadata.commitHash)
+        };
+    }
     return unsupportedProviderConfig(source);
 }
 export function prepareProviderDestination(destination, options = {}) {
@@ -111,6 +135,14 @@ export function prepareProviderDestination(destination, options = {}) {
             }
         };
     }
+    if (isHuggingFaceProvider(destination)) {
+        return {
+            destination_id: destinationId,
+            provider: "huggingface",
+            logical_prefix: destination.path,
+            metadata: huggingFaceMetadata(destination)
+        };
+    }
     return unsupportedProviderConfig(destination);
 }
 export async function createMultipartUpload(input) {
@@ -169,13 +201,51 @@ export async function abortMultipartUpload(destination, objectKey, uploadId) {
     }
     throw new Error(`multipart abort is not supported for ${destination.provider}`);
 }
+/** Provider metadata only. These operations never read or proxy object bytes. */
+export async function listMultipartParts(destination, objectKey, uploadId) {
+    if (!isS3CompatibleProvider(destination))
+        return unsupportedProviderConfig(destination);
+    const parts = [];
+    let marker;
+    do {
+        const page = await createS3CompatibleClient(destination).send(new ListPartsCommand({
+            Bucket: destination.bucket, Key: objectKey, UploadId: uploadId, MaxParts: 1000, PartNumberMarker: marker
+        }));
+        for (const part of page.Parts ?? []) {
+            if (!part.PartNumber || !part.ETag || !Number.isSafeInteger(part.Size))
+                throw new Error("invalid multipart part metadata");
+            parts.push({ partNumber: part.PartNumber, etag: part.ETag, size: part.Size });
+        }
+        const next = page.IsTruncated ? page.NextPartNumberMarker : undefined;
+        if (page.IsTruncated && (!next || next === marker))
+            throw new Error("invalid multipart pagination");
+        marker = next;
+    } while (marker);
+    return parts;
+}
+export async function completeMultipartUpload(input) {
+    if (!isS3CompatibleProvider(input.destination))
+        return unsupportedProviderConfig(input.destination);
+    const result = await createS3CompatibleClient(input.destination).send(new CompleteMultipartUploadCommand({
+        Bucket: input.destination.bucket, Key: input.objectKey, UploadId: input.uploadId,
+        MultipartUpload: { Parts: [...input.parts].sort((a, b) => a.partNumber - b.partNumber)
+                .map((part) => ({ PartNumber: part.partNumber, ETag: part.etag })) }
+    }));
+    return { etag: result.ETag, versionId: result.VersionId };
+}
+export async function inspectDestinationObject(destination, objectKey) {
+    if (!isS3CompatibleProvider(destination))
+        return unsupportedProviderConfig(destination);
+    const result = await createS3CompatibleClient(destination).send(new HeadObjectCommand({ Bucket: destination.bucket, Key: objectKey }));
+    return { size: result.ContentLength, etag: result.ETag, versionId: result.VersionId, metadata: result.Metadata ?? {} };
+}
 export async function signDestinationRoute(input) {
     const targetObjectKey = input.target.object_key;
     if (!targetObjectKey) {
         throw new Error("destination signing target is missing object_key");
     }
     const [destUrl, sourceRoute] = await Promise.all([
-        signDestinationUrl({
+        input.destUrl ?? signDestinationUrl({
             destination: input.destination,
             objectKey: targetObjectKey,
             uploadId: input.uploadId,
@@ -234,17 +304,25 @@ export async function signSourceReadRange(input) {
             url: await getSignedUrl(client, new GetObjectCommand({
                 Bucket: input.source.bucket,
                 Key: input.source.key,
-                Range: range
+                Range: range,
+                IfMatch: input.ifMatch,
+                VersionId: input.versionId
             }), { expiresIn: input.expiresIn }),
-            headers: { Range: range }
+            headers: { Range: range, ...(input.ifMatch ? { "If-Match": input.ifMatch } : {}) }
         };
     }
+    if (input.ifMatch || input.versionId)
+        throw new Error("conditional source ranges require S3-compatible storage");
     if (isHippiusProvider(input.source)) {
         return {
             url: await hippiusPresign(input.fetchImpl ?? globalThis.fetch, input.source.base_url ?? "https://api.hippius.com", input.source.api_token, input.source.bucket, input.source.key, "get", input.expiresIn),
             headers: { Range: range }
         };
     }
+    if (isHuggingFaceProvider(input.source)) {
+        const metadata = await huggingFaceFileMetadata(input.fetchImpl ?? globalThis.fetch, input.source);
+        return { url: metadata.url, headers: { Range: range } };
+    }
     return unsupportedProviderConfig(input.source);
 }
 export async function signDestinationReadRange(input) {
@@ -266,6 +344,15 @@ export async function signDestinationReadRange(input) {
             headers: { Range: range }
         };
     }
+    if (isHuggingFaceProvider(input.destination)) {
+        // Read-back resolves the committed file. Before the commit lands the bytes exist only as
+        // uncommitted LFS parts, which the Hub does not expose.
+        const metadata = await huggingFaceFileMetadata(input.fetchImpl ?? globalThis.fetch, {
+            ...input.destination,
+            path: input.objectKey
+        });
+        return { url: metadata.url, headers: { Range: range } };
+    }
     return unsupportedProviderConfig(input.destination);
 }
 async function signSourceRoute(input) {
@@ -290,9 +377,13 @@ async function signSourceRoute(input) {
             headers: { Range: range }
         };
     }
+    if (isHuggingFaceProvider(input.source)) {
+        const metadata = await huggingFaceFileMetadata(input.fetchImpl ?? globalThis.fetch, input.source);
+        return { url: metadata.url, headers: { Range: range } };
+    }
     return unsupportedProviderConfig(input.source);
 }
-async function signDestinationUrl(input) {
+export async function signDestinationUrl(input) {
     if (isS3CompatibleProvider(input.destination)) {
         const client = createS3CompatibleClient(input.destination);
         if (input.uploadId && input.partNumber) {
@@ -300,11 +391,14 @@ async function signDestinationUrl(input) {
                 Bucket: input.destination.bucket,
                 Key: input.objectKey,
                 UploadId: input.uploadId,
-                PartNumber: input.partNumber
+                PartNumber: input.partNumber,
+                ContentMD5: input.contentMd5
             }), { expiresIn: input.expiresIn });
         }
-        return getSignedUrl(client, new PutObjectCommand({ Bucket: input.destination.bucket, Key: input.objectKey }), { expiresIn: input.expiresIn });
+        return getSignedUrl(client, new PutObjectCommand({ Bucket: input.destination.bucket, Key: input.objectKey, ContentMD5: input.contentMd5 }), { expiresIn: input.expiresIn });
     }
+    if (input.contentMd5)
+        throw new Error("checksum-bound uploads require S3-compatible storage");
     if (isHippiusProvider(input.destination)) {
         return hippiusPresign(input.fetchImpl ?? globalThis.fetch, input.destination.base_url ?? "https://api.hippius.com", input.destination.api_token, input.destination.bucket, input.objectKey, "put", input.expiresIn);
     }
@@ -396,6 +490,22 @@ function s3CompatibleMetadata(source, endpoint = s3CompatibleEndpoint(source)) {
 function isHippiusProvider(config) {
     return config.provider === "hippius" && "api_token" in config;
 }
+export function isHuggingFaceProvider(config) {
+    return config.provider === "huggingface" && "repo_id" in config;
+}
+function huggingFaceMetadata(config, etag, commitHash) {
+    return compactMetadata({
+        driver: "huggingface",
+        repo_id: config.repo_id,
+        repo_type: huggingFaceRepoType(config),
+        revision: huggingFaceRevision(config),
+        path: config.path,
+        endpoint: huggingFaceEndpoint(config),
+        // For an LFS blob the Hub's linked ETag is the object's sha256.
+        sha256: etag,
+        commit_hash: commitHash
+    });
+}
 async function hippiusPresign(fetchImpl, baseUrl, token, bucket, key, action, expiresIn) {
     const url = new URL(`/api/objectstore/buckets/${bucket}/presigned-url/`, baseUrl);
     url.searchParams.set("key", key);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@beam-network/sdk",
-    "version": "0.5.15",
+    "version": "0.5.17-dev.0",
     "description": "TypeScript SDK for BEAM transfer creation and management.",
     "type": "module",
     "license": "MIT",