@mastra/azure 0.0.0-ag-example-20260516005230

package/dist/chunk-74CBJSIM.cjs

@@ -0,0 +1,764 @@
+'use strict';
+
+var storageBlob = require('@azure/storage-blob');
+var workspace = require('@mastra/core/workspace');
+var storage = require('@mastra/core/storage');
+
+// src/blob/filesystem/index.ts
+var 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(error) {
+  if (!error || typeof error !== "object") return false;
+  const restErr = error;
+  return restErr.statusCode === 404;
+}
+function isAccessDeniedError(error) {
+  if (!error || typeof error !== "object") return false;
+  const restErr = error;
+  return restErr.statusCode === 403;
+}
+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);
+}
+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 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(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 = storageBlob.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) {
+        const credential = new storageBlob.StorageSharedKeyCredential(this.accountName, this.accountKey);
+        serviceClient = new storageBlob.BlobServiceClient(baseUrl, credential);
+      } else if (this.sasToken) {
+        const sas = this.sasToken.replace(/^\?+/, "");
+        const separator = baseUrl.includes("?") ? "&" : "?";
+        serviceClient = new storageBlob.BlobServiceClient(`${baseUrl}${separator}${sas}`);
+      } else if (this.useDefaultCredential) {
+        try {
+          const identity = await import('@azure/identity');
+          const credential = new identity.DefaultAzureCredential();
+          serviceClient = new storageBlob.BlobServiceClient(baseUrl, credential);
+        } catch {
+          throw new Error(
+            "DefaultAzureCredential requires @azure/identity to be installed. Install it with: npm install @azure/identity"
+          );
+        }
+      } else {
+        serviceClient = new storageBlob.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 workspace.PermissionError(path, `${operation} (filesystem is read-only)`);
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // File Operations
+  // ---------------------------------------------------------------------------
+  async readFile(path, options) {
+    const containerClient = await this.getReadyContainer();
+    const blobClient = containerClient.getBlockBlobClient(this.toKey(path));
+    try {
+      const response = await blobClient.download(0);
+      const buffer = await streamToBuffer(response.readableStreamBody);
+      if (options?.encoding) {
+        return buffer.toString(options.encoding);
+      }
+      return buffer;
+    } catch (error) {
+      if (isNotFoundError(error)) {
+        throw new 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 workspace.FileExistsError(path);
+    }
+    const body = toBuffer(content);
+    const contentType = getMimeType(path);
+    const blobClient = containerClient.getBlockBlobClient(this.toKey(path));
+    await blobClient.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 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");
+    const isDir = await this.isDirectory(path);
+    if (isDir) {
+      await this.rmdir(path, { recursive: true, force: options?.force });
+      return;
+    }
+    const containerClient = await this.getReadyContainer();
+    const blobClient = containerClient.getBlobClient(this.toKey(path));
+    try {
+      await blobClient.delete();
+    } catch (error) {
+      if (isNotFoundError(error)) {
+        if (options?.force) return;
+        throw new 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 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: storageBlob.BlobSASPermissions.parse("r"),
+        expiresOn: new Date(Date.now() + 5 * 60 * 1e3)
+      });
+      const properties = await srcBlob.getProperties();
+      if (properties.contentLength === 0) {
+        await destBlob.getBlockBlobClient().upload(Buffer.alloc(0), 0);
+        return;
+      }
+      const MAX_SYNC_COPY_SIZE = 256 * 1024 * 1024;
+      if ((properties.contentLength ?? 0) <= MAX_SYNC_COPY_SIZE) {
+        await destBlob.syncCopyFromURL(sasUrl);
+      } else {
+        const poller = await destBlob.beginCopyFromURL(sasUrl);
+        await poller.pollUntilDone();
+      }
+    } catch (error) {
+      if (isNotFoundError(error)) {
+        throw new 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 });
+  }
+  // ---------------------------------------------------------------------------
+  // Directory Operations
+  // ---------------------------------------------------------------------------
+  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) {
+      const iter = containerClient.listBlobsFlat({ prefix });
+      const first = await iter.next();
+      if (!first.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) {
+          const extensions = Array.isArray(options.extension) ? options.extension : [options.extension];
+          if (!extensions.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) {
+            const extensions = Array.isArray(options.extension) ? options.extension : [options.extension];
+            if (!extensions.some((ext) => relativePath.endsWith(ext))) {
+              continue;
+            }
+          }
+          entries.push({
+            name: relativePath,
+            type: "file",
+            size: item.properties.contentLength
+          });
+        }
+      }
+    }
+    return entries;
+  }
+  // ---------------------------------------------------------------------------
+  // Path Operations
+  // ---------------------------------------------------------------------------
+  async exists(path) {
+    const key = this.toKey(path);
+    if (!key) return true;
+    const containerClient = await this.getReadyContainer();
+    const blobClient = containerClient.getBlobClient(key);
+    const exists = await blobClient.exists();
+    if (exists) return true;
+    const prefix = key.replace(/\/$/, "") + "/";
+    const iter = containerClient.listBlobsFlat({ prefix });
+    const first = await iter.next();
+    return !first.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 containerClient = await this.getReadyContainer();
+    const blobClient = containerClient.getBlobClient(key);
+    try {
+      const properties = await blobClient.getProperties();
+      const name = path.split("/").pop() ?? "";
+      return {
+        name,
+        path,
+        type: "file",
+        size: properties.contentLength ?? 0,
+        createdAt: properties.createdOn ?? /* @__PURE__ */ new Date(),
+        modifiedAt: properties.lastModified ?? /* @__PURE__ */ new Date()
+      };
+    } catch (error) {
+      if (!isNotFoundError(error)) throw this.handleError(error);
+      const isDir = await this.isDirectory(path);
+      if (isDir) {
+        const name = path.split("/").filter(Boolean).pop() ?? "";
+        return {
+          name,
+          path,
+          type: "directory",
+          size: 0,
+          createdAt: /* @__PURE__ */ new Date(),
+          modifiedAt: /* @__PURE__ */ new Date()
+        };
+      }
+      throw new workspace.FileNotFoundError(path);
+    }
+  }
+  async isFile(path) {
+    const key = this.toKey(path);
+    if (!key) return false;
+    const containerClient = await this.getReadyContainer();
+    const blobClient = containerClient.getBlobClient(key);
+    return blobClient.exists();
+  }
+  async isDirectory(path) {
+    const key = this.toKey(path);
+    if (!key) return true;
+    const containerClient = await this.getReadyContainer();
+    const prefix = key.replace(/\/$/, "") + "/";
+    const iter = containerClient.listBlobsFlat({ prefix });
+    const first = await iter.next();
+    return !first.done;
+  }
+  // ---------------------------------------------------------------------------
+  // Lifecycle
+  // ---------------------------------------------------------------------------
+  async init() {
+    const containerClient = await this.getContainerClient();
+    try {
+      if (this.sasToken) {
+        const iter = containerClient.listBlobsFlat({ prefix: this.prefix });
+        await iter.next();
+        return;
+      }
+      const exists = await containerClient.exists();
+      if (!exists) {
+        const err = 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;
+  }
+};
+function trimSlashes2(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 isNotFoundError2(error) {
+  if (!error || typeof error !== "object") return false;
+  return error.statusCode === 404;
+}
+var BATCH_DELETE_SIZE = 256;
+var AzureBlobStore = class extends 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 ? trimSlashes2(options.prefix) + "/" : "mastra_skill_blobs/";
+  }
+  async getContainerClient() {
+    if (this._containerClient) return this._containerClient;
+    let serviceClient;
+    if (this.connectionString) {
+      serviceClient = storageBlob.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) {
+        const credential = new storageBlob.StorageSharedKeyCredential(this.accountName, this.accountKey);
+        serviceClient = new storageBlob.BlobServiceClient(baseUrl, credential);
+      } else if (this.sasToken) {
+        const sas = this.sasToken.replace(/^\?+/, "");
+        const separator = baseUrl.includes("?") ? "&" : "?";
+        serviceClient = new storageBlob.BlobServiceClient(`${baseUrl}${separator}${sas}`);
+      } else if (this.useDefaultCredential) {
+        try {
+          const identity = await import('@azure/identity');
+          const credential = new identity.DefaultAzureCredential();
+          serviceClient = new storageBlob.BlobServiceClient(baseUrl, credential);
+        } catch {
+          throw new Error(
+            "DefaultAzureCredential requires @azure/identity to be installed. Install it with: npm install @azure/identity"
+          );
+        }
+      } else {
+        serviceClient = new storageBlob.BlobServiceClient(baseUrl);
+      }
+    }
+    this._containerClient = serviceClient.getContainerClient(this.containerName);
+    return this._containerClient;
+  }
+  toKey(hash) {
+    return this.prefix + hash;
+  }
+  async init() {
+  }
+  async put(entry) {
+    const containerClient = await this.getContainerClient();
+    const blobClient = containerClient.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 containerClient = await this.getContainerClient();
+    const blobClient = containerClient.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 (isNotFoundError2(error)) return null;
+      throw error;
+    }
+  }
+  async has(hash) {
+    const containerClient = await this.getContainerClient();
+    const blobClient = containerClient.getBlockBlobClient(this.toKey(hash));
+    try {
+      await blobClient.getProperties();
+      return true;
+    } catch (error) {
+      if (isNotFoundError2(error)) return false;
+      throw error;
+    }
+  }
+  async delete(hash) {
+    const containerClient = await this.getContainerClient();
+    const blobClient = containerClient.getBlockBlobClient(this.toKey(hash));
+    const response = await blobClient.deleteIfExists();
+    return response.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);
+  }
+};
+
+// src/blob/provider.ts
+var 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)
+};
+var 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)
+};
+
+exports.AzureBlobFilesystem = AzureBlobFilesystem;
+exports.AzureBlobStore = AzureBlobStore;
+exports.azureBlobFilesystemProvider = azureBlobFilesystemProvider;
+exports.azureBlobStoreProvider = azureBlobStoreProvider;
+//# sourceMappingURL=chunk-74CBJSIM.cjs.map
+//# sourceMappingURL=chunk-74CBJSIM.cjs.map