@mastra/azure 0.3.0 → 0.3.1-alpha.0

package/dist/blob-B1rO2XRY.cjs

@@ -0,0 +1,743 @@
+let _azure_storage_blob = require("@azure/storage-blob");
+let _mastra_core_workspace = require("@mastra/core/workspace");
+let _mastra_core_storage = require("@mastra/core/storage");
+//#region src/blob/filesystem/index.ts
+/**
+* Azure Blob Storage Filesystem Provider
+*
+* A filesystem implementation backed by Azure Blob Storage.
+*/
+const MIME_TYPES = {
+	".txt": "text/plain",
+	".md": "text/markdown",
+	".markdown": "text/markdown",
+	".html": "text/html",
+	".htm": "text/html",
+	".css": "text/css",
+	".csv": "text/csv",
+	".xml": "text/xml",
+	".js": "text/javascript",
+	".mjs": "text/javascript",
+	".ts": "text/typescript",
+	".tsx": "text/typescript",
+	".jsx": "text/javascript",
+	".json": "application/json",
+	".yaml": "text/yaml",
+	".yml": "text/yaml",
+	".py": "text/x-python",
+	".rb": "text/x-ruby",
+	".sh": "text/x-shellscript",
+	".bash": "text/x-shellscript",
+	".png": "image/png",
+	".jpg": "image/jpeg",
+	".jpeg": "image/jpeg",
+	".gif": "image/gif",
+	".svg": "image/svg+xml",
+	".webp": "image/webp",
+	".ico": "image/x-icon",
+	".pdf": "application/pdf",
+	".zip": "application/zip",
+	".gz": "application/gzip",
+	".tar": "application/x-tar"
+};
+function getMimeType(path) {
+	const ext = path.toLowerCase().match(/\.[^.]+$/)?.[0];
+	return ext ? MIME_TYPES[ext] ?? "application/octet-stream" : "application/octet-stream";
+}
+function isNotFoundError$1(error) {
+	if (!error || typeof error !== "object") return false;
+	return error.statusCode === 404;
+}
+function isAccessDeniedError(error) {
+	if (!error || typeof error !== "object") return false;
+	return error.statusCode === 403;
+}
+/** Trim leading and trailing slashes without regex (avoids polynomial regex on user input). */
+function trimSlashes$1(s) {
+	let start = 0;
+	let end = s.length;
+	while (start < end && s[start] === "/") start++;
+	while (end > start && s[end - 1] === "/") end--;
+	return s.slice(start, end);
+}
+async function streamToBuffer(stream) {
+	if (!stream) return Buffer.alloc(0);
+	const chunks = [];
+	for await (const chunk of stream) chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+	return Buffer.concat(chunks);
+}
+function toBuffer(content) {
+	if (Buffer.isBuffer(content)) return content;
+	return typeof content === "string" ? Buffer.from(content, "utf-8") : Buffer.from(content);
+}
+var AzureBlobFilesystem = class extends _mastra_core_workspace.MastraFilesystem {
+	id;
+	name = "AzureBlobFilesystem";
+	provider = "azure-blob";
+	readOnly;
+	status = "pending";
+	displayName;
+	icon = "azure-blob";
+	description;
+	containerName;
+	accountName;
+	accountKey;
+	sasToken;
+	connectionString;
+	useDefaultCredential;
+	prefix;
+	endpoint;
+	_containerClient = null;
+	constructor(options) {
+		super({
+			...options,
+			name: "AzureBlobFilesystem"
+		});
+		this.id = options.id ?? `azure-fs-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+		this.containerName = options.container;
+		this.accountName = options.accountName;
+		this.accountKey = options.accountKey;
+		this.sasToken = options.sasToken;
+		this.connectionString = options.connectionString;
+		this.useDefaultCredential = options.useDefaultCredential ?? false;
+		this.prefix = options.prefix ? trimSlashes$1(options.prefix) + "/" : "";
+		this.endpoint = options.endpoint;
+		this.displayName = options.displayName ?? "Azure Blob Storage";
+		this.icon = options.icon ?? "azure-blob";
+		this.description = options.description;
+		this.readOnly = options.readOnly;
+	}
+	/**
+	* Get the underlying ContainerClient for direct access to Azure Blob APIs.
+	*
+	* Use this when you need features not exposed through the WorkspaceFilesystem
+	* interface (e.g., SAS URL generation, lease management, etc.).
+	*
+	* This is async because DefaultAzureCredential requires a dynamic import.
+	* For non-DefaultAzureCredential auth methods, the promise resolves immediately.
+	*/
+	getContainer() {
+		return this.getContainerClient();
+	}
+	getMountConfig() {
+		const config = {
+			type: "azure-blob",
+			container: this.containerName
+		};
+		if (this.connectionString) config.connectionString = this.connectionString;
+		else {
+			if (this.accountName) config.accountName = this.accountName;
+			if (this.accountKey) config.accountKey = this.accountKey;
+			if (this.sasToken) config.sasToken = this.sasToken;
+		}
+		if (this.useDefaultCredential) config.useDefaultCredential = true;
+		if (this.endpoint) config.endpoint = this.endpoint;
+		if (this.prefix) config.prefix = this.prefix;
+		if (this.readOnly) config.readOnly = true;
+		return config;
+	}
+	getInfo() {
+		return {
+			id: this.id,
+			name: this.name,
+			provider: this.provider,
+			status: this.status,
+			error: this.error,
+			readOnly: this.readOnly,
+			icon: this.icon,
+			metadata: {
+				container: this.containerName,
+				...this.endpoint && { endpoint: this.endpoint },
+				...this.prefix && { prefix: this.prefix }
+			}
+		};
+	}
+	getInstructions() {
+		const access = this.readOnly ? "Read-only" : "Persistent";
+		return `Azure Blob Storage in container "${this.containerName}". ${access} storage - files are retained across sessions.`;
+	}
+	async getContainerClient() {
+		if (this._containerClient) return this._containerClient;
+		let serviceClient;
+		if (this.connectionString) serviceClient = _azure_storage_blob.BlobServiceClient.fromConnectionString(this.connectionString);
+		else {
+			if (!this.endpoint && !this.accountName) throw new Error("Azure Blob Storage requires either a connectionString, or an accountName/endpoint. Provide at least one of: connectionString, accountName, or endpoint.");
+			const baseUrl = this.endpoint ?? `https://${this.accountName}.blob.core.windows.net`;
+			if (this.accountName && this.accountKey) serviceClient = new _azure_storage_blob.BlobServiceClient(baseUrl, new _azure_storage_blob.StorageSharedKeyCredential(this.accountName, this.accountKey));
+			else if (this.sasToken) {
+				const sas = this.sasToken.replace(/^\?+/, "");
+				serviceClient = new _azure_storage_blob.BlobServiceClient(`${baseUrl}${baseUrl.includes("?") ? "&" : "?"}${sas}`);
+			} else if (this.useDefaultCredential) try {
+				serviceClient = new _azure_storage_blob.BlobServiceClient(baseUrl, new (await (import("@azure/identity"))).DefaultAzureCredential());
+			} catch {
+				throw new Error("DefaultAzureCredential requires @azure/identity to be installed. Install it with: npm install @azure/identity");
+			}
+			else serviceClient = new _azure_storage_blob.BlobServiceClient(baseUrl);
+		}
+		this._containerClient = serviceClient.getContainerClient(this.containerName);
+		return this._containerClient;
+	}
+	async getReadyContainer() {
+		await this.ensureReady();
+		return this.getContainerClient();
+	}
+	toKey(path) {
+		const cleanPath = path.replace(/^\/+/, "");
+		return this.prefix + cleanPath;
+	}
+	handleError(error) {
+		if (isAccessDeniedError(error)) {
+			this.status = "error";
+			this.error = "Access denied - check credentials and container permissions";
+		}
+		return error;
+	}
+	assertWritable(path, operation) {
+		if (this.readOnly) throw new _mastra_core_workspace.PermissionError(path, `${operation} (filesystem is read-only)`);
+	}
+	async readFile(path, options) {
+		const blobClient = (await this.getReadyContainer()).getBlockBlobClient(this.toKey(path));
+		try {
+			const buffer = await streamToBuffer((await blobClient.download(0)).readableStreamBody);
+			if (options?.encoding) return buffer.toString(options.encoding);
+			return buffer;
+		} catch (error) {
+			if (isNotFoundError$1(error)) throw new _mastra_core_workspace.FileNotFoundError(path);
+			throw this.handleError(error);
+		}
+	}
+	async writeFile(path, content, options) {
+		this.assertWritable(path, "write");
+		const containerClient = await this.getReadyContainer();
+		if (options?.overwrite === false && await this.exists(path)) throw new _mastra_core_workspace.FileExistsError(path);
+		const body = toBuffer(content);
+		const contentType = getMimeType(path);
+		await containerClient.getBlockBlobClient(this.toKey(path)).upload(body, body.length, { blobHTTPHeaders: { blobContentType: contentType } });
+	}
+	async appendFile(path, content) {
+		this.assertWritable(path, "append");
+		let existing = Buffer.alloc(0);
+		try {
+			const read = await this.readFile(path);
+			existing = Buffer.isBuffer(read) ? read : Buffer.from(read);
+		} catch (error) {
+			if (error instanceof _mastra_core_workspace.FileNotFoundError) {} else throw error;
+		}
+		const appendBuffer = toBuffer(content);
+		await this.writeFile(path, Buffer.concat([existing, appendBuffer]));
+	}
+	async deleteFile(path, options) {
+		this.assertWritable(path, "delete");
+		if (await this.isDirectory(path)) {
+			await this.rmdir(path, {
+				recursive: true,
+				force: options?.force
+			});
+			return;
+		}
+		const blobClient = (await this.getReadyContainer()).getBlobClient(this.toKey(path));
+		try {
+			await blobClient.delete();
+		} catch (error) {
+			if (isNotFoundError$1(error)) {
+				if (options?.force) return;
+				throw new _mastra_core_workspace.FileNotFoundError(path);
+			}
+			throw this.handleError(error);
+		}
+	}
+	async copyFile(src, dest, options) {
+		this.assertWritable(dest, "copy");
+		if (options?.overwrite === false && await this.exists(dest)) throw new _mastra_core_workspace.FileExistsError(dest);
+		const containerClient = await this.getReadyContainer();
+		const srcBlob = containerClient.getBlobClient(this.toKey(src));
+		const destBlob = containerClient.getBlobClient(this.toKey(dest));
+		try {
+			const sasUrl = await srcBlob.generateSasUrl({
+				permissions: _azure_storage_blob.BlobSASPermissions.parse("r"),
+				expiresOn: new Date(Date.now() + 300 * 1e3)
+			});
+			const properties = await srcBlob.getProperties();
+			if (properties.contentLength === 0) {
+				await destBlob.getBlockBlobClient().upload(Buffer.alloc(0), 0);
+				return;
+			}
+			if ((properties.contentLength ?? 0) <= 256 * 1024 * 1024) await destBlob.syncCopyFromURL(sasUrl);
+			else await (await destBlob.beginCopyFromURL(sasUrl)).pollUntilDone();
+		} catch (error) {
+			if (isNotFoundError$1(error)) throw new _mastra_core_workspace.FileNotFoundError(src);
+			if (error instanceof Error && (error.message.includes("generateSasUrl") || error.message.includes("SAS") && error.message.includes("shared key credential"))) {
+				const content = await this.readFile(src);
+				await this.writeFile(dest, content);
+				return;
+			}
+			throw this.handleError(error);
+		}
+	}
+	async moveFile(src, dest, options) {
+		this.assertWritable(dest, "move");
+		await this.copyFile(src, dest, options);
+		await this.deleteFile(src, { force: true });
+	}
+	async mkdir(_path, _options) {}
+	async rmdir(path, options) {
+		this.assertWritable(path, "rmdir");
+		const containerClient = await this.getReadyContainer();
+		const prefix = this.toKey(path).replace(/\/$/, "") + "/";
+		if (!options?.recursive) {
+			if (!(await containerClient.listBlobsFlat({ prefix }).next()).done) throw new Error(`Directory not empty: ${path}`);
+			return;
+		}
+		let blobNames = [];
+		for await (const blob of containerClient.listBlobsFlat({ prefix })) {
+			blobNames.push(blob.name);
+			if (blobNames.length >= 256) {
+				await this.deleteBlobBatch(containerClient, blobNames);
+				blobNames = [];
+			}
+		}
+		if (blobNames.length > 0) await this.deleteBlobBatch(containerClient, blobNames);
+	}
+	async deleteBlobBatch(containerClient, blobNames) {
+		const blobClients = blobNames.map((name) => containerClient.getBlobClient(name));
+		await containerClient.getBlobBatchClient().deleteBlobs(blobClients);
+	}
+	async readdir(path, options) {
+		const containerClient = await this.getReadyContainer();
+		const prefix = this.toKey(path).replace(/\/$/, "");
+		const searchPrefix = prefix ? prefix + "/" : "";
+		const entries = [];
+		const seenDirs = /* @__PURE__ */ new Set();
+		if (options?.recursive) for await (const blob of containerClient.listBlobsFlat({ prefix: searchPrefix })) {
+			const key = blob.name;
+			if (!key || key === searchPrefix) continue;
+			const relativePath = key.slice(searchPrefix.length);
+			if (!relativePath) continue;
+			if (relativePath.endsWith("/")) {
+				const dirName = relativePath.slice(0, -1);
+				if (!seenDirs.has(dirName)) {
+					seenDirs.add(dirName);
+					entries.push({
+						name: dirName,
+						type: "directory"
+					});
+				}
+				continue;
+			}
+			if (options?.extension) {
+				if (!(Array.isArray(options.extension) ? options.extension : [options.extension]).some((ext) => relativePath.endsWith(ext))) continue;
+			}
+			entries.push({
+				name: relativePath,
+				type: "file",
+				size: blob.properties.contentLength
+			});
+		}
+		else for await (const item of containerClient.listBlobsByHierarchy("/", { prefix: searchPrefix })) if (item.kind === "prefix") {
+			const dirName = item.name.slice(searchPrefix.length).replace(/\/$/, "");
+			if (dirName && !seenDirs.has(dirName)) {
+				seenDirs.add(dirName);
+				entries.push({
+					name: dirName,
+					type: "directory"
+				});
+			}
+		} else {
+			const key = item.name;
+			if (!key || key === searchPrefix) continue;
+			const relativePath = key.slice(searchPrefix.length);
+			if (!relativePath) continue;
+			if (relativePath.endsWith("/")) {
+				const dirName = relativePath.slice(0, -1);
+				if (!seenDirs.has(dirName)) {
+					seenDirs.add(dirName);
+					entries.push({
+						name: dirName,
+						type: "directory"
+					});
+				}
+				continue;
+			}
+			if (options?.extension) {
+				if (!(Array.isArray(options.extension) ? options.extension : [options.extension]).some((ext) => relativePath.endsWith(ext))) continue;
+			}
+			entries.push({
+				name: relativePath,
+				type: "file",
+				size: item.properties.contentLength
+			});
+		}
+		return entries;
+	}
+	async exists(path) {
+		const key = this.toKey(path);
+		if (!key) return true;
+		const containerClient = await this.getReadyContainer();
+		if (await containerClient.getBlobClient(key).exists()) return true;
+		const prefix = key.replace(/\/$/, "") + "/";
+		return !(await containerClient.listBlobsFlat({ prefix }).next()).done;
+	}
+	async stat(path) {
+		const key = this.toKey(path);
+		if (!key) return {
+			name: "",
+			path,
+			type: "directory",
+			size: 0,
+			createdAt: /* @__PURE__ */ new Date(),
+			modifiedAt: /* @__PURE__ */ new Date()
+		};
+		const blobClient = (await this.getReadyContainer()).getBlobClient(key);
+		try {
+			const properties = await blobClient.getProperties();
+			return {
+				name: path.split("/").pop() ?? "",
+				path,
+				type: "file",
+				size: properties.contentLength ?? 0,
+				createdAt: properties.createdOn ?? /* @__PURE__ */ new Date(),
+				modifiedAt: properties.lastModified ?? /* @__PURE__ */ new Date()
+			};
+		} catch (error) {
+			if (!isNotFoundError$1(error)) throw this.handleError(error);
+			if (await this.isDirectory(path)) return {
+				name: path.split("/").filter(Boolean).pop() ?? "",
+				path,
+				type: "directory",
+				size: 0,
+				createdAt: /* @__PURE__ */ new Date(),
+				modifiedAt: /* @__PURE__ */ new Date()
+			};
+			throw new _mastra_core_workspace.FileNotFoundError(path);
+		}
+	}
+	async isFile(path) {
+		const key = this.toKey(path);
+		if (!key) return false;
+		return (await this.getReadyContainer()).getBlobClient(key).exists();
+	}
+	async isDirectory(path) {
+		const key = this.toKey(path);
+		if (!key) return true;
+		const containerClient = await this.getReadyContainer();
+		const prefix = key.replace(/\/$/, "") + "/";
+		return !(await containerClient.listBlobsFlat({ prefix }).next()).done;
+	}
+	async init() {
+		const containerClient = await this.getContainerClient();
+		try {
+			if (this.sasToken) {
+				await containerClient.listBlobsFlat({ prefix: this.prefix }).next();
+				return;
+			}
+			if (!await containerClient.exists()) {
+				const err = /* @__PURE__ */ new Error(`Container "${this.containerName}" does not exist`);
+				err.status = 404;
+				throw err;
+			}
+		} catch (error) {
+			if (error.status) throw error;
+			const statusCode = error.statusCode;
+			if (typeof statusCode === "number") {
+				const message = error instanceof Error ? error.message : String(error);
+				const err = new Error(message);
+				err.status = statusCode;
+				throw err;
+			}
+			throw error;
+		}
+	}
+	async destroy() {
+		this._containerClient = null;
+	}
+};
+//#endregion
+//#region src/blob/blob-store/index.ts
+/** Trim leading and trailing slashes. */
+function trimSlashes(s) {
+	let start = 0;
+	let end = s.length;
+	while (start < end && s[start] === "/") start++;
+	while (end > start && s[end - 1] === "/") end--;
+	return s.slice(start, end);
+}
+function isNotFoundError(error) {
+	if (!error || typeof error !== "object") return false;
+	return error.statusCode === 404;
+}
+/** Azure metadata batch limit per request. */
+const BATCH_DELETE_SIZE = 256;
+/**
+* Azure Blob Storage-backed content-addressable blob store for skill versioning.
+*
+* Each blob is stored as a block blob keyed by its SHA-256 hash. Metadata
+* (size, mimeType, createdAt) is stored as Azure blob metadata.
+*
+* Since blobs are content-addressable, writes are idempotent — the same hash
+* always maps to the same content, so overwrites are safe and equivalent to
+* a no-op.
+*
+* @example Connection string
+* ```typescript
+* import { AzureBlobStore } from '@mastra/azure/blob';
+*
+* const blobs = new AzureBlobStore({
+*   container: 'my-skill-blobs',
+*   connectionString: process.env.AZURE_STORAGE_CONNECTION_STRING!,
+* });
+* ```
+*
+* @example Account key
+* ```typescript
+* import { AzureBlobStore } from '@mastra/azure/blob';
+*
+* const blobs = new AzureBlobStore({
+*   container: 'my-skill-blobs',
+*   accountName: process.env.AZURE_STORAGE_ACCOUNT_NAME!,
+*   accountKey: process.env.AZURE_STORAGE_ACCOUNT_KEY!,
+* });
+* ```
+*/
+var AzureBlobStore = class extends _mastra_core_storage.BlobStore {
+	containerName;
+	accountName;
+	accountKey;
+	sasToken;
+	connectionString;
+	useDefaultCredential;
+	endpoint;
+	prefix;
+	_containerClient = null;
+	constructor(options) {
+		super();
+		this.containerName = options.container;
+		this.accountName = options.accountName;
+		this.accountKey = options.accountKey;
+		this.sasToken = options.sasToken;
+		this.connectionString = options.connectionString;
+		this.useDefaultCredential = options.useDefaultCredential ?? false;
+		this.endpoint = options.endpoint;
+		this.prefix = options.prefix ? trimSlashes(options.prefix) + "/" : "mastra_skill_blobs/";
+	}
+	async getContainerClient() {
+		if (this._containerClient) return this._containerClient;
+		let serviceClient;
+		if (this.connectionString) serviceClient = _azure_storage_blob.BlobServiceClient.fromConnectionString(this.connectionString);
+		else {
+			if (!this.endpoint && !this.accountName) throw new Error("Azure Blob Storage requires either a connectionString, or an accountName/endpoint. Provide at least one of: connectionString, accountName, or endpoint.");
+			const baseUrl = this.endpoint ?? `https://${this.accountName}.blob.core.windows.net`;
+			if (this.accountName && this.accountKey) serviceClient = new _azure_storage_blob.BlobServiceClient(baseUrl, new _azure_storage_blob.StorageSharedKeyCredential(this.accountName, this.accountKey));
+			else if (this.sasToken) {
+				const sas = this.sasToken.replace(/^\?+/, "");
+				serviceClient = new _azure_storage_blob.BlobServiceClient(`${baseUrl}${baseUrl.includes("?") ? "&" : "?"}${sas}`);
+			} else if (this.useDefaultCredential) try {
+				serviceClient = new _azure_storage_blob.BlobServiceClient(baseUrl, new (await (import("@azure/identity"))).DefaultAzureCredential());
+			} catch {
+				throw new Error("DefaultAzureCredential requires @azure/identity to be installed. Install it with: npm install @azure/identity");
+			}
+			else serviceClient = new _azure_storage_blob.BlobServiceClient(baseUrl);
+		}
+		this._containerClient = serviceClient.getContainerClient(this.containerName);
+		return this._containerClient;
+	}
+	toKey(hash) {
+		return this.prefix + hash;
+	}
+	async init() {}
+	async put(entry) {
+		const blobClient = (await this.getContainerClient()).getBlockBlobClient(this.toKey(entry.hash));
+		const now = entry.createdAt ?? /* @__PURE__ */ new Date();
+		const buffer = Buffer.from(entry.content, "utf-8");
+		await blobClient.uploadData(buffer, {
+			blobHTTPHeaders: { blobContentType: entry.mimeType ?? "application/octet-stream" },
+			metadata: {
+				size: String(entry.size),
+				createdat: now.toISOString(),
+				...entry.mimeType ? { mimetype: entry.mimeType } : {}
+			}
+		});
+	}
+	async get(hash) {
+		const blobClient = (await this.getContainerClient()).getBlockBlobClient(this.toKey(hash));
+		try {
+			const buffer = await blobClient.downloadToBuffer();
+			const properties = await blobClient.getProperties();
+			const metadata = properties.metadata ?? {};
+			const content = buffer.toString("utf-8");
+			return {
+				hash,
+				content,
+				size: metadata.size != null ? Number(metadata.size) : Buffer.byteLength(content, "utf-8"),
+				mimeType: metadata.mimetype || properties.contentType || void 0,
+				createdAt: metadata.createdat ? new Date(metadata.createdat) : /* @__PURE__ */ new Date()
+			};
+		} catch (error) {
+			if (isNotFoundError(error)) return null;
+			throw error;
+		}
+	}
+	async has(hash) {
+		const blobClient = (await this.getContainerClient()).getBlockBlobClient(this.toKey(hash));
+		try {
+			await blobClient.getProperties();
+			return true;
+		} catch (error) {
+			if (isNotFoundError(error)) return false;
+			throw error;
+		}
+	}
+	async delete(hash) {
+		return (await (await this.getContainerClient()).getBlockBlobClient(this.toKey(hash)).deleteIfExists()).succeeded;
+	}
+	async putMany(entries) {
+		if (entries.length === 0) return;
+		await Promise.all(entries.map((entry) => this.put(entry)));
+	}
+	async getMany(hashes) {
+		const result = /* @__PURE__ */ new Map();
+		if (hashes.length === 0) return result;
+		const entries = await Promise.all(hashes.map((hash) => this.get(hash)));
+		for (const entry of entries) if (entry) result.set(entry.hash, entry);
+		return result;
+	}
+	async dangerouslyClearAll() {
+		const containerClient = await this.getContainerClient();
+		let batch = [];
+		for await (const blob of containerClient.listBlobsFlat({ prefix: this.prefix })) {
+			batch.push(blob.name);
+			if (batch.length >= BATCH_DELETE_SIZE) {
+				await this.deleteBlobBatch(containerClient, batch);
+				batch = [];
+			}
+		}
+		if (batch.length > 0) await this.deleteBlobBatch(containerClient, batch);
+	}
+	async deleteBlobBatch(containerClient, blobNames) {
+		const blobClients = blobNames.map((name) => containerClient.getBlobClient(name));
+		await containerClient.getBlobBatchClient().deleteBlobs(blobClients);
+	}
+};
+//#endregion
+//#region src/blob/provider.ts
+const azureBlobFilesystemProvider = {
+	id: "azure-blob",
+	name: "Azure Blob Storage",
+	description: "Azure Blob Storage container",
+	configSchema: {
+		type: "object",
+		required: ["container"],
+		properties: {
+			container: {
+				type: "string",
+				description: "Azure Blob container name"
+			},
+			accountName: {
+				type: "string",
+				description: "Storage account name"
+			},
+			accountKey: {
+				type: "string",
+				description: "Storage account key"
+			},
+			sasToken: {
+				type: "string",
+				description: "Shared Access Signature token"
+			},
+			connectionString: {
+				type: "string",
+				description: "Full connection string (overrides other auth options)"
+			},
+			useDefaultCredential: {
+				type: "boolean",
+				description: "Use DefaultAzureCredential (requires @azure/identity)",
+				default: false
+			},
+			prefix: {
+				type: "string",
+				description: "Key prefix (acts like a subdirectory)"
+			},
+			readOnly: {
+				type: "boolean",
+				description: "Mount as read-only",
+				default: false
+			},
+			endpoint: {
+				type: "string",
+				description: "Custom endpoint URL (for Azurite emulator)"
+			}
+		}
+	},
+	createFilesystem: (config) => new AzureBlobFilesystem(config)
+};
+const azureBlobStoreProvider = {
+	id: "azure-blob",
+	name: "Azure Blob Store",
+	description: "Content-addressable blob storage backed by Azure Blob Storage",
+	configSchema: {
+		type: "object",
+		required: ["container"],
+		properties: {
+			container: {
+				type: "string",
+				description: "Azure Blob container name"
+			},
+			accountName: {
+				type: "string",
+				description: "Storage account name"
+			},
+			accountKey: {
+				type: "string",
+				description: "Storage account key"
+			},
+			sasToken: {
+				type: "string",
+				description: "Shared Access Signature token"
+			},
+			connectionString: {
+				type: "string",
+				description: "Full connection string (overrides other auth options)"
+			},
+			useDefaultCredential: {
+				type: "boolean",
+				description: "Use DefaultAzureCredential (requires @azure/identity)",
+				default: false
+			},
+			prefix: {
+				type: "string",
+				description: "Key prefix for blob objects (default: mastra_skill_blobs/)"
+			},
+			endpoint: {
+				type: "string",
+				description: "Custom endpoint URL (for Azurite emulator)"
+			}
+		}
+	},
+	createBlobStore: (config) => new AzureBlobStore(config)
+};
+//#endregion
+Object.defineProperty(exports, "AzureBlobFilesystem", {
+	enumerable: true,
+	get: function() {
+		return AzureBlobFilesystem;
+	}
+});
+Object.defineProperty(exports, "AzureBlobStore", {
+	enumerable: true,
+	get: function() {
+		return AzureBlobStore;
+	}
+});
+Object.defineProperty(exports, "azureBlobFilesystemProvider", {
+	enumerable: true,
+	get: function() {
+		return azureBlobFilesystemProvider;
+	}
+});
+Object.defineProperty(exports, "azureBlobStoreProvider", {
+	enumerable: true,
+	get: function() {
+		return azureBlobStoreProvider;
+	}
+});
+
+//# sourceMappingURL=blob-B1rO2XRY.cjs.map