@scalemule/sdk 0.0.1 → 0.0.2

package/dist/index.mjs

@@ -577,81 +577,76 @@ var ScaleMuleClient = class {
    * Single upload with XMLHttpRequest for progress tracking.
    * Supports abort via AbortSignal.
    */
-  uploadWithXHR(url, buildFormData, onProgress, signal, maxRetries = this.maxRetries) {
-    return new Promise(async (resolve) => {
-      let lastError = null;
-      for (let attempt = 0; attempt <= maxRetries; attempt++) {
-        const result = await new Promise((res) => {
-          const xhr = new XMLHttpRequest();
-          if (signal) {
-            if (signal.aborted) {
-              res({ data: null, error: { code: "aborted", message: "Upload aborted", status: 0 } });
-              return;
-            }
-            signal.addEventListener("abort", () => xhr.abort(), { once: true });
+  async uploadWithXHR(url, buildFormData, onProgress, signal, maxRetries = this.maxRetries) {
+    let lastError = null;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      const result = await new Promise((res) => {
+        const xhr = new XMLHttpRequest();
+        if (signal) {
+          if (signal.aborted) {
+            res({ data: null, error: { code: "aborted", message: "Upload aborted", status: 0 } });
+            return;
           }
-          xhr.upload.addEventListener("progress", (event) => {
-            if (event.lengthComputable) {
-              onProgress(Math.round(event.loaded / event.total * 100));
-            }
-          });
-          xhr.addEventListener("load", () => {
-            try {
-              const data = JSON.parse(xhr.responseText);
-              if (xhr.status >= 200 && xhr.status < 300) {
-                const result2 = data?.data !== void 0 ? data.data : data;
-                res({ data: result2, error: null });
-              } else {
-                res({
-                  data: null,
-                  error: {
-                    code: data?.error?.code || statusToErrorCode(xhr.status),
-                    message: data?.error?.message || data?.message || "Upload failed",
-                    status: xhr.status,
-                    details: data?.error?.details
-                  }
-                });
-              }
-            } catch {
-              res({ data: null, error: { code: "internal_error", message: "Failed to parse response", status: 0 } });
+          signal.addEventListener("abort", () => xhr.abort(), { once: true });
+        }
+        xhr.upload.addEventListener("progress", (event) => {
+          if (event.lengthComputable) {
+            onProgress(Math.round(event.loaded / event.total * 100));
+          }
+        });
+        xhr.addEventListener("load", () => {
+          try {
+            const data = JSON.parse(xhr.responseText);
+            if (xhr.status >= 200 && xhr.status < 300) {
+              const result2 = data?.data !== void 0 ? data.data : data;
+              res({ data: result2, error: null });
+            } else {
+              res({
+                data: null,
+                error: {
+                  code: data?.error?.code || statusToErrorCode(xhr.status),
+                  message: data?.error?.message || data?.message || "Upload failed",
+                  status: xhr.status,
+                  details: data?.error?.details
+                }
+              });
             }
-          });
-          xhr.addEventListener("error", () => {
-            res({ data: null, error: { code: "upload_error", message: "Upload failed", status: 0 } });
-          });
-          xhr.addEventListener("abort", () => {
-            res({ data: null, error: { code: "aborted", message: "Upload aborted", status: 0 } });
-          });
-          xhr.open("POST", url);
-          xhr.setRequestHeader("x-api-key", this.apiKey);
-          if (this.sessionToken) {
-            xhr.setRequestHeader("Authorization", `Bearer ${this.sessionToken}`);
+          } catch {
+            res({ data: null, error: { code: "internal_error", message: "Failed to parse response", status: 0 } });
           }
-          xhr.send(buildFormData());
         });
-        if (result.error === null) {
-          resolve(result);
-          return;
-        }
-        const isRetryable = result.error.code === "upload_error" || result.error.code === "network_error" || RETRYABLE_STATUS_CODES.has(result.error.status);
-        if (result.error.code === "aborted") {
-          resolve(result);
-          return;
-        }
-        if (attempt < maxRetries && isRetryable) {
-          lastError = result.error;
-          onProgress(0);
-          await sleep(getBackoffDelay(attempt, this.backoffMs));
-          continue;
+        xhr.addEventListener("error", () => {
+          res({ data: null, error: { code: "upload_error", message: "Upload failed", status: 0 } });
+        });
+        xhr.addEventListener("abort", () => {
+          res({ data: null, error: { code: "aborted", message: "Upload aborted", status: 0 } });
+        });
+        xhr.open("POST", url);
+        xhr.setRequestHeader("x-api-key", this.apiKey);
+        if (this.sessionToken) {
+          xhr.setRequestHeader("Authorization", `Bearer ${this.sessionToken}`);
         }
-        resolve(result);
-        return;
-      }
-      resolve({
-        data: null,
-        error: lastError || { code: "upload_error", message: "Upload failed", status: 0 }
+        xhr.send(buildFormData());
       });
-    });
+      if (result.error === null) {
+        return result;
+      }
+      const isRetryable = result.error.code === "upload_error" || result.error.code === "network_error" || RETRYABLE_STATUS_CODES.has(result.error.status);
+      if (result.error.code === "aborted") {
+        return result;
+      }
+      if (attempt < maxRetries && isRetryable) {
+        lastError = result.error;
+        onProgress(0);
+        await sleep(getBackoffDelay(attempt, this.backoffMs));
+        continue;
+      }
+      return result;
+    }
+    return {
+      data: null,
+      error: lastError || { code: "upload_error", message: "Upload failed", status: 0 }
+    };
   }
   // --------------------------------------------------------------------------
   // Offline Queue Sync
@@ -744,7 +739,12 @@ var ServiceModule = class {
   // File upload (delegates to client.upload)
   // --------------------------------------------------------------------------
   _upload(path, file, additionalFields, options) {
-    return this.client.upload(`${this.basePath}${path}`, file, additionalFields, this.resolveOptions(options));
+    return this.client.upload(
+      `${this.basePath}${path}`,
+      file,
+      additionalFields,
+      this.resolveOptions(options)
+    );
   }
   // --------------------------------------------------------------------------
   // Query string helper (available to subclasses)
@@ -1439,13 +1439,17 @@ var StorageService = class extends ServiceModule {
     const directStart = Date.now();
     const requestOpts = this.withSessionHeader(sessionId, options);
     const filename = options?.filename || file.name || "file";
-    const initResult = await this.post("/signed-url/upload", {
-      filename,
-      content_type: file.type || "application/octet-stream",
-      size_bytes: file.size,
-      is_public: options?.isPublic ?? true,
-      metadata: options?.metadata
-    }, requestOpts);
+    const initResult = await this.post(
+      "/signed-url/upload",
+      {
+        filename,
+        content_type: file.type || "application/octet-stream",
+        size_bytes: file.size,
+        is_public: options?.isPublic ?? true,
+        metadata: options?.metadata
+      },
+      requestOpts
+    );
     if (initResult.error) {
       telemetry?.emit(sessionId, "upload.failed", { step: "presign", error: initResult.error.message });
       return { data: null, error: initResult.error };
@@ -1471,14 +1475,27 @@ var StorageService = class extends ServiceModule {
       });
       return { data: null, error: uploadResult.error };
     }
-    const completeResult = await this.post("/signed-url/complete", {
-      file_id,
-      completion_token
-    }, requestOpts);
+    const completeResult = await this.post(
+      "/signed-url/complete",
+      {
+        file_id,
+        completion_token
+      },
+      requestOpts
+    );
     if (completeResult.error) {
-      telemetry?.emit(sessionId, "upload.failed", { step: "complete", error: completeResult.error.message, file_id, duration_ms: Date.now() - directStart });
+      telemetry?.emit(sessionId, "upload.failed", {
+        step: "complete",
+        error: completeResult.error.message,
+        file_id,
+        duration_ms: Date.now() - directStart
+      });
     } else {
-      telemetry?.emit(sessionId, "upload.completed", { file_id, size_bytes: file.size, duration_ms: Date.now() - directStart });
+      telemetry?.emit(sessionId, "upload.completed", {
+        file_id,
+        size_bytes: file.size,
+        duration_ms: Date.now() - directStart
+      });
     }
     return completeResult;
   }
@@ -1513,14 +1530,17 @@ var StorageService = class extends ServiceModule {
           });
         }
       } catch (err) {
-        telemetry?.emit(sessionId, "upload.retried", { step: "resume_load", error: err instanceof Error ? err.message : "Resume store unavailable" });
+        telemetry?.emit(sessionId, "upload.retried", {
+          step: "resume_load",
+          error: err instanceof Error ? err.message : "Resume store unavailable"
+        });
         resumeStore = null;
         resumeData = null;
       }
     }
     let startData;
     let completionToken;
-    let completedParts = /* @__PURE__ */ new Map();
+    const completedParts = /* @__PURE__ */ new Map();
     if (resumeData) {
       startData = {
         upload_session_id: resumeData.upload_session_id,
@@ -1549,15 +1569,19 @@ var StorageService = class extends ServiceModule {
         );
       } catch {
       }
-      const startResult = await this.post("/signed-url/multipart/start", {
-        filename,
-        content_type: file.type || "application/octet-stream",
-        size_bytes: file.size,
-        is_public: options?.isPublic ?? true,
-        metadata: options?.metadata,
-        chunk_size: options?.chunkSize,
-        ...clientUploadKey ? { client_upload_key: clientUploadKey } : {}
-      }, requestOpts);
+      const startResult = await this.post(
+        "/signed-url/multipart/start",
+        {
+          filename,
+          content_type: file.type || "application/octet-stream",
+          size_bytes: file.size,
+          is_public: options?.isPublic ?? true,
+          metadata: options?.metadata,
+          chunk_size: options?.chunkSize,
+          ...clientUploadKey ? { client_upload_key: clientUploadKey } : {}
+        },
+        requestOpts
+      );
       if (startResult.error) {
         telemetry?.emit(sessionId, "upload.multipart.aborted", { error: startResult.error.message });
         return { data: null, error: startResult.error };
@@ -1586,11 +1610,14 @@ var StorageService = class extends ServiceModule {
           created_at: Date.now()
         });
       } catch (err) {
-        telemetry?.emit(sessionId, "upload.retried", { step: "resume_save", error: err instanceof Error ? err.message : "Resume save failed" });
+        telemetry?.emit(sessionId, "upload.retried", {
+          step: "resume_save",
+          error: err instanceof Error ? err.message : "Resume save failed"
+        });
       }
     }
     const maxConcurrency = options?.maxConcurrency || this.defaultConcurrency();
-    let availableUrls = /* @__PURE__ */ new Map();
+    const availableUrls = /* @__PURE__ */ new Map();
     if (startData.part_urls.length > 0) {
       for (const pu of startData.part_urls) {
         availableUrls.set(pu.part_number, pu);
@@ -1611,7 +1638,11 @@ var StorageService = class extends ServiceModule {
       }
       const milestone = Math.floor(percent / 25) * 25;
       if (milestone > lastProgressMilestone && milestone < 100) {
-        telemetry?.emit(sessionId, "upload.progress", { percent: milestone, uploaded_parts: uploadedCount, total_parts });
+        telemetry?.emit(sessionId, "upload.progress", {
+          percent: milestone,
+          uploaded_parts: uploadedCount,
+          total_parts
+        });
         lastProgressMilestone = milestone;
       }
     };
@@ -1711,7 +1742,11 @@ var StorageService = class extends ServiceModule {
               );
               await resumeStore.updatePart(resumeKey, result.partNum, result.etag);
             } catch (err) {
-              telemetry?.emit(sessionId, "upload.retried", { step: "resume_update", part_number: result.partNum, error: err instanceof Error ? err.message : "Resume update failed" });
+              telemetry?.emit(sessionId, "upload.retried", {
+                step: "resume_update",
+                part_number: result.partNum,
+                error: err instanceof Error ? err.message : "Resume update failed"
+              });
             }
           }
         } else {
@@ -1745,15 +1780,30 @@ var StorageService = class extends ServiceModule {
         );
         await resumeStore.remove(resumeKey);
       } catch (err) {
-        telemetry?.emit(sessionId, "upload.retried", { step: "resume_cleanup", error: err instanceof Error ? err.message : "Resume cleanup failed" });
+        telemetry?.emit(sessionId, "upload.retried", {
+          step: "resume_cleanup",
+          error: err instanceof Error ? err.message : "Resume cleanup failed"
+        });
       }
     }
     if (completeResult.error) {
-      telemetry?.emit(sessionId, "upload.multipart.aborted", { file_id, error: completeResult.error.message, duration_ms: Date.now() - multipartStart });
+      telemetry?.emit(sessionId, "upload.multipart.aborted", {
+        file_id,
+        error: completeResult.error.message,
+        duration_ms: Date.now() - multipartStart
+      });
       return { data: null, error: completeResult.error };
     }
-    telemetry?.emit(sessionId, "upload.multipart.completed", { file_id, size_bytes: file.size, duration_ms: Date.now() - multipartStart });
-    telemetry?.emit(sessionId, "upload.completed", { file_id, size_bytes: file.size, duration_ms: Date.now() - multipartStart });
+    telemetry?.emit(sessionId, "upload.multipart.completed", {
+      file_id,
+      size_bytes: file.size,
+      duration_ms: Date.now() - multipartStart
+    });
+    telemetry?.emit(sessionId, "upload.completed", {
+      file_id,
+      size_bytes: file.size,
+      duration_ms: Date.now() - multipartStart
+    });
     options?.onProgress?.(100);
     const d = completeResult.data;
     return {
@@ -1773,10 +1823,14 @@ var StorageService = class extends ServiceModule {
   // --------------------------------------------------------------------------
   async abortMultipart(uploadSessionId, completionToken, requestOpts) {
     try {
-      await this.post("/signed-url/multipart/abort", {
-        upload_session_id: uploadSessionId,
-        ...completionToken ? { completion_token: completionToken } : {}
-      }, requestOpts);
+      await this.post(
+        "/signed-url/multipart/abort",
+        {
+          upload_session_id: uploadSessionId,
+          ...completionToken ? { completion_token: completionToken } : {}
+        },
+        requestOpts
+      );
     } catch {
     }
   }
@@ -1791,25 +1845,33 @@ var StorageService = class extends ServiceModule {
    * Flow: server calls getUploadUrl() → returns URL to client → client PUTs to S3 → server calls completeUpload()
    */
   async getUploadUrl(filename, contentType, options, requestOptions) {
-    return this.post("/signed-url/upload", {
-      filename,
-      content_type: contentType,
-      is_public: options?.isPublic ?? true,
-      expires_in: options?.expiresIn ?? 3600,
-      metadata: options?.metadata
-    }, requestOptions);
+    return this.post(
+      "/signed-url/upload",
+      {
+        filename,
+        content_type: contentType,
+        is_public: options?.isPublic ?? true,
+        expires_in: options?.expiresIn ?? 3600,
+        metadata: options?.metadata
+      },
+      requestOptions
+    );
   }
   /**
    * Complete a presigned upload after the file has been uploaded to S3.
    * Triggers scan and makes the file available.
    */
   async completeUpload(fileId, completionToken, options, requestOptions) {
-    return this.post("/signed-url/complete", {
-      file_id: fileId,
-      completion_token: completionToken,
-      size_bytes: options?.sizeBytes,
-      checksum: options?.checksum
-    }, requestOptions);
+    return this.post(
+      "/signed-url/complete",
+      {
+        file_id: fileId,
+        completion_token: completionToken,
+        size_bytes: options?.sizeBytes,
+        checksum: options?.checksum
+      },
+      requestOptions
+    );
   }
   // --------------------------------------------------------------------------
   // Multipart Public API (for advanced/server-side usage)
@@ -1820,11 +1882,15 @@ var StorageService = class extends ServiceModule {
   }
   /** Get presigned URLs for specific part numbers. */
   async getMultipartPartUrls(uploadSessionId, partNumbers, completionToken, requestOptions) {
-    return this.post("/signed-url/multipart/part-urls", {
-      upload_session_id: uploadSessionId,
-      part_numbers: partNumbers,
-      ...completionToken ? { completion_token: completionToken } : {}
-    }, requestOptions);
+    return this.post(
+      "/signed-url/multipart/part-urls",
+      {
+        upload_session_id: uploadSessionId,
+        part_numbers: partNumbers,
+        ...completionToken ? { completion_token: completionToken } : {}
+      },
+      requestOptions
+    );
   }
   /** Complete a multipart upload. */
   async completeMultipartUpload(params, requestOptions) {
@@ -1832,10 +1898,14 @@ var StorageService = class extends ServiceModule {
   }
   /** Abort a multipart upload. */
   async abortMultipartUpload(uploadSessionId, completionToken, requestOptions) {
-    return this.post("/signed-url/multipart/abort", {
-      upload_session_id: uploadSessionId,
-      ...completionToken ? { completion_token: completionToken } : {}
-    }, requestOptions);
+    return this.post(
+      "/signed-url/multipart/abort",
+      {
+        upload_session_id: uploadSessionId,
+        ...completionToken ? { completion_token: completionToken } : {}
+      },
+      requestOptions
+    );
   }
   // --------------------------------------------------------------------------
   // File Operations
@@ -1884,7 +1954,11 @@ var StorageService = class extends ServiceModule {
    * Public files get 7-day signed URLs; private files get 1-hour signed URLs.
    */
   async updateVisibility(fileId, isPublic, options) {
-    return this.patch(`/files/${fileId}/visibility`, { is_public: isPublic }, options);
+    return this.patch(
+      `/files/${fileId}/visibility`,
+      { is_public: isPublic },
+      options
+    );
   }
   // --------------------------------------------------------------------------
   // Legacy methods (backward compat)
@@ -2028,10 +2102,14 @@ var StorageService = class extends ServiceModule {
           resolve({ data: null, error: { code: "aborted", message: "Upload aborted", status: 0 } });
           return;
         }
-        signal.addEventListener("abort", () => {
-          clearStallTimer();
-          xhr.abort();
-        }, { once: true });
+        signal.addEventListener(
+          "abort",
+          () => {
+            clearStallTimer();
+            xhr.abort();
+          },
+          { once: true }
+        );
       }
       xhr.upload.addEventListener("progress", (event) => {
         resetStallTimer();
@@ -2118,7 +2196,11 @@ var StorageService = class extends ServiceModule {
           return { error: `Part upload failed: ${response.status}`, status: response.status, code: "s3_error" };
         }
         if (attempt === RETRY_DELAYS.length - 1) {
-          return { error: `Part upload failed after retries: ${response.status}`, status: response.status, code: "s3_error" };
+          return {
+            error: `Part upload failed after retries: ${response.status}`,
+            status: response.status,
+            code: "s3_error"
+          };
         }
       } catch (err) {
         clearTimeout(timer);
@@ -2158,7 +2240,7 @@ var StorageService = class extends ServiceModule {
   }
   async maybeCompress(file, config, sessionId, telemetry) {
     try {
-      const { maybeCompressImage } = await import("./upload-compression-CWKEDQYS.mjs");
+      const { maybeCompressImage } = await import("./upload-compression-VOUJRAIM.mjs");
       return await maybeCompressImage(file, config, sessionId, telemetry);
     } catch {
       return null;
@@ -2624,14 +2706,18 @@ var VideoService = class extends ServiceModule {
     const chunkSize = Math.max(options?.chunkSize ?? DEFAULT_CHUNK_SIZE, MIN_CHUNK_SIZE);
     const totalChunks = Math.ceil(file.size / chunkSize);
     const filename = options?.filename || file.name || "video";
-    const startResult = await this.post("/upload-start", {
-      filename,
-      content_type: file.type || "video/mp4",
-      size_bytes: file.size,
-      title: options?.title,
-      description: options?.description,
-      metadata: options?.metadata
-    }, requestOptions);
+    const startResult = await this.post(
+      "/upload-start",
+      {
+        filename,
+        content_type: file.type || "video/mp4",
+        size_bytes: file.size,
+        title: options?.title,
+        description: options?.description,
+        metadata: options?.metadata
+      },
+      requestOptions
+    );
     if (startResult.error) return { data: null, error: startResult.error };
     const { video_id, upload_id } = startResult.data;
     const parts = [];
@@ -2643,13 +2729,7 @@ var VideoService = class extends ServiceModule {
       const end = Math.min(start + chunkSize, file.size);
       const chunk = file.slice(start, end);
       const partNumber = i + 1;
-      const partResult = await this.uploadPart(
-        video_id,
-        upload_id,
-        partNumber,
-        chunk,
-        options?.signal
-      );
+      const partResult = await this.uploadPart(video_id, upload_id, partNumber, chunk, options?.signal);
       if (partResult.error) return { data: null, error: partResult.error };
       parts.push({
         part_number: partNumber,
@@ -2660,10 +2740,14 @@ var VideoService = class extends ServiceModule {
         options.onProgress(progress);
       }
     }
-    const completeResult = await this.post(`/${video_id}/upload-complete`, {
-      upload_id,
-      parts
-    }, requestOptions);
+    const completeResult = await this.post(
+      `/${video_id}/upload-complete`,
+      {
+        upload_id,
+        parts
+      },
+      requestOptions
+    );
     return completeResult;
   }
   // --------------------------------------------------------------------------
@@ -2692,7 +2776,10 @@ var VideoService = class extends ServiceModule {
   }
   /** Get video analytics (views, watch time, etc.). */
   async getAnalytics(videoId, options) {
-    return super._get(`/${videoId}/analytics`, options);
+    return super._get(
+      `/${videoId}/analytics`,
+      options
+    );
   }
   /**
    * Update a video's access mode (public/private).
@@ -2892,7 +2979,10 @@ var ChatService = class extends ServiceModule {
     return this.post(`/conversations/${conversationId}/messages`, data, options);
   }
   async getMessages(conversationId, options, requestOptions) {
-    return this._get(this.withQuery(`/conversations/${conversationId}/messages`, options), requestOptions);
+    return this._get(
+      this.withQuery(`/conversations/${conversationId}/messages`, options),
+      requestOptions
+    );
   }
   async editMessage(messageId, data, options) {
     return this.patch(`/messages/${messageId}`, data, options);
@@ -3129,7 +3219,10 @@ var BillingService = class extends ServiceModule {
     return this._list("/transactions", params, options);
   }
   async getTransactionSummary(params, options) {
-    return this._get(this.withQuery("/transactions/summary", params), options);
+    return this._get(
+      this.withQuery("/transactions/summary", params),
+      options
+    );
   }
   // --------------------------------------------------------------------------
   // Setup Sessions
@@ -3156,7 +3249,11 @@ var BillingService = class extends ServiceModule {
     return this.post(`/connected-subscriptions/${id}/cancel`, data, options);
   }
   async listConnectedSubscriptions(params, options) {
-    return this._list("/connected-subscriptions", params, options);
+    return this._list(
+      "/connected-subscriptions",
+      params,
+      options
+    );
   }
   async createConnectedSetupIntent(data, options) {
     return this.post("/connected-setup-intents", data, options);
@@ -3202,7 +3299,11 @@ var AnalyticsService = class extends ServiceModule {
   // Identity
   // --------------------------------------------------------------------------
   async identify(userId, traits, anonymousId, options) {
-    return this.post("/identify", { user_id: userId, traits, anonymous_id: anonymousId }, options);
+    return this.post(
+      "/identify",
+      { user_id: userId, traits, anonymous_id: anonymousId },
+      options
+    );
   }
   async alias(userId, anonymousId, options) {
     return this.post("/alias", { user_id: userId, anonymous_id: anonymousId }, options);
@@ -3392,22 +3493,30 @@ var PermissionsService = class extends ServiceModule {
   /** Check a single permission. Supports identity_type for unified model. */
   async check(identityId, permission, options) {
     const { identityType, resourceType, resourceId, ...reqOptions } = options || {};
-    return this.post("/check", {
-      identity_id: identityId,
-      identity_type: identityType || "user",
-      permission,
-      resource_type: resourceType,
-      resource_id: resourceId
-    }, reqOptions);
+    return this.post(
+      "/check",
+      {
+        identity_id: identityId,
+        identity_type: identityType || "user",
+        permission,
+        resource_type: resourceType,
+        resource_id: resourceId
+      },
+      reqOptions
+    );
   }
   /** Batch check multiple permissions for an identity. */
   async batchCheck(identityId, permissions, options) {
     const { identityType, ...reqOptions } = options || {};
-    return this.post("/batch-check", {
-      identity_id: identityId,
-      identity_type: identityType || "user",
-      permissions
-    }, reqOptions);
+    return this.post(
+      "/batch-check",
+      {
+        identity_id: identityId,
+        identity_type: identityType || "user",
+        permissions
+      },
+      reqOptions
+    );
   }
   /** Fetch the full permission matrix for an identity (single request, no N+1). */
   async getMatrix(identityId, identityType = "user", options) {
@@ -3851,7 +3960,7 @@ var PhotoService = class extends ServiceModule {
    * // Profile avatar at 48px -> snaps to 150px
    * const url = sm.photo.getOptimalUrl(photoId, 48)
    * ```
-  */
+   */
   getOptimalUrl(photoId, displayWidth, options) {
     const requestedDpr = options?.dpr ?? 1;
     const dpr = Number.isFinite(requestedDpr) && requestedDpr > 0 ? requestedDpr : 1;
@@ -3880,7 +3989,9 @@ var PhotoService = class extends ServiceModule {
    * ```
    */
   getSrcSet(photoId) {
-    return PHOTO_BREAKPOINTS.map((size) => `${this.getTransformUrl(photoId, { width: size, height: size, fit: "cover" })} ${size}w`).join(", ");
+    return PHOTO_BREAKPOINTS.map(
+      (size) => `${this.getTransformUrl(photoId, { width: size, height: size, fit: "cover" })} ${size}w`
+    ).join(", ");
   }
   /**
    * Register a photo from an already-uploaded storage file.
@@ -3892,10 +4003,14 @@ var PhotoService = class extends ServiceModule {
    * Returns the photo record with `id` that can be used with `getTransformUrl()`.
    */
   async register(registerOptions, requestOptions) {
-    return this.post("/register", {
-      file_id: registerOptions.fileId,
-      sm_user_id: registerOptions.userId
-    }, requestOptions);
+    return this.post(
+      "/register",
+      {
+        file_id: registerOptions.fileId,
+        sm_user_id: registerOptions.userId
+      },
+      requestOptions
+    );
   }
   /** @deprecated Use upload() instead */
   async uploadPhoto(file, options) {
@@ -4163,6 +4278,442 @@ var FlagContentService = class extends ServiceModule {
   }
 };
 
+// src/services/agent-auth.ts
+var AgentAuthService = class extends ServiceModule {
+  constructor() {
+    super(...arguments);
+    this.basePath = "/v1/auth";
+  }
+  async registerAgent(data, options) {
+    return this.post("/register/agent", data, options);
+  }
+  async listTokens(options) {
+    return this._get("/agent-tokens", options);
+  }
+  async createToken(data, options) {
+    return this.post("/agent-tokens", data, options);
+  }
+  async revokeToken(id, options) {
+    return this.del(`/agent-tokens/${id}`, options);
+  }
+  async rotateToken(id, options) {
+    return this.post(`/agent-tokens/${id}/rotate`, void 0, options);
+  }
+  async exchangeToken(data, options) {
+    return this.post("/agent-tokens/exchange", data, options);
+  }
+  async listSigningKeys(options) {
+    return this._get("/agent-signing-keys", options);
+  }
+  async addSigningKey(data, options) {
+    return this.post("/agent-signing-keys", data, options);
+  }
+  async revokeSigningKey(id, options) {
+    return this.del(`/agent-signing-keys/${id}`, options);
+  }
+  async getProfile(options) {
+    return this._get("/agent-profile", options);
+  }
+  async updateProfile(data, options) {
+    return this.patch("/agent-profile", data, options);
+  }
+  async getSecurityPolicy(appId, options) {
+    return this._get(`/applications/${appId}/agent-security`, options);
+  }
+  async updateSecurityPolicy(appId, data, options) {
+    return this.put(`/applications/${appId}/agent-security`, data, options);
+  }
+};
+
+// src/services/agents.ts
+var AgentsService = class extends ServiceModule {
+  constructor() {
+    super(...arguments);
+    this.basePath = "/v1/agents";
+  }
+  // Orchestrated registration
+  async registerAgent(data, options) {
+    return this.post("/register-agent", data, options);
+  }
+  async deactivateAgent(id, options) {
+    return this.post(`/agents/${id}/deactivate`, void 0, options);
+  }
+  // Agent CRUD
+  async create(data, options) {
+    return this.post("/agents", data, options);
+  }
+  async list(params, options) {
+    return this._list("/agents", params, options);
+  }
+  async get(id, options) {
+    return this._get(`/agents/${id}`, options);
+  }
+  async update(id, data, options) {
+    return this.patch(`/agents/${id}`, data, options);
+  }
+  async remove(id, options) {
+    return this.del(`/agents/${id}`, options);
+  }
+  async setDefaultWorkspace(id, data, options) {
+    return this.post(`/agents/${id}/set-default-workspace`, data, options);
+  }
+  // Runtime Templates
+  async createTemplate(data, options) {
+    return this.post("/runtime-templates", data, options);
+  }
+  async listTemplates(params, options) {
+    return this._list("/runtime-templates", params, options);
+  }
+  async getTemplate(id, options) {
+    return this._get(
+      `/runtime-templates/${id}`,
+      options
+    );
+  }
+  async createTemplateVersion(id, data, options) {
+    return this.post(`/runtime-templates/${id}/versions`, data, options);
+  }
+  async listTemplateVersions(id, options) {
+    return this._get(`/runtime-templates/${id}/versions`, options);
+  }
+  // Workspaces
+  async createWorkspace(data, options) {
+    return this.post("/workspaces", data, options);
+  }
+  async listWorkspaces(params, options) {
+    return this._list("/workspaces", params, options);
+  }
+  async getWorkspace(id, options) {
+    return this._get(`/workspaces/${id}`, options);
+  }
+  async updateWorkspace(id, data, options) {
+    return this.patch(`/workspaces/${id}`, data, options);
+  }
+  async addOsAccount(workspaceId, data, options) {
+    return this.post(`/workspaces/${workspaceId}/os-accounts`, data, options);
+  }
+};
+
+// src/services/agent-projects.ts
+var AgentProjectsService = class extends ServiceModule {
+  constructor() {
+    super(...arguments);
+    this.basePath = "/v1/agent-projects";
+  }
+  withAppId(path, applicationId) {
+    return applicationId ? this.withQuery(path, { application_id: applicationId }) : path;
+  }
+  // Projects
+  async createProject(data, applicationId, options) {
+    return this.post(this.withAppId("/projects", applicationId), data, options);
+  }
+  async listProjects(params, options) {
+    return this._list("/projects", params, options);
+  }
+  async getProject(id, applicationId, options) {
+    return this._get(this.withAppId(`/projects/${id}`, applicationId), options);
+  }
+  async updateProject(id, data, applicationId, options) {
+    return this.patch(this.withAppId(`/projects/${id}`, applicationId), data, options);
+  }
+  // Members (use auth user_id)
+  async addMember(projectId, data, applicationId, options) {
+    return this.post(this.withAppId(`/projects/${projectId}/members`, applicationId), data, options);
+  }
+  async listMembers(projectId, applicationId, options) {
+    const result = await this._get(
+      this.withAppId(`/projects/${projectId}/members`, applicationId),
+      options
+    );
+    return { data: result.data?.members ?? [], error: result.error };
+  }
+  async updateMember(projectId, userId, data, applicationId, options) {
+    return this.patch(
+      this.withAppId(`/projects/${projectId}/members/${userId}`, applicationId),
+      data,
+      options
+    );
+  }
+  async removeMember(projectId, userId, applicationId, options) {
+    return this.del(this.withAppId(`/projects/${projectId}/members/${userId}`, applicationId), options);
+  }
+  // Tasks
+  async createTask(projectId, data, applicationId, options) {
+    return this.post(this.withAppId(`/projects/${projectId}/tasks`, applicationId), data, options);
+  }
+  async listTasks(projectId, params, options) {
+    return this._list(`/projects/${projectId}/tasks`, params, options);
+  }
+  async getTask(id, applicationId, options) {
+    return this._get(this.withAppId(`/tasks/${id}`, applicationId), options);
+  }
+  async updateTask(id, data, applicationId, options) {
+    return this.patch(this.withAppId(`/tasks/${id}`, applicationId), data, options);
+  }
+  // Lifecycle (use registry agent_id)
+  async claimNext(agentId, applicationId, options) {
+    const result = await this.post(
+      this.withAppId("/tasks/next-available", applicationId),
+      { agent_id: agentId },
+      options
+    );
+    if (!result.data || typeof result.data !== "object" || !("task_id" in result.data)) {
+      return { data: null, error: result.error };
+    }
+    return result;
+  }
+  async claim(taskId, agentId, applicationId, options) {
+    return this.post(
+      this.withAppId(`/tasks/${taskId}/claim`, applicationId),
+      { agent_id: agentId },
+      options
+    );
+  }
+  async heartbeat(taskId, agentId, applicationId, options) {
+    return this.post(
+      this.withAppId(`/tasks/${taskId}/heartbeat`, applicationId),
+      { agent_id: agentId },
+      options
+    );
+  }
+  async submit(taskId, data, applicationId, options) {
+    return this.post(this.withAppId(`/tasks/${taskId}/submit`, applicationId), data, options);
+  }
+  async block(taskId, data, applicationId, options) {
+    return this.post(this.withAppId(`/tasks/${taskId}/block`, applicationId), data, options);
+  }
+  // Assignment
+  async assignAgent(taskId, data, applicationId, options) {
+    return this.post(this.withAppId(`/tasks/${taskId}/assign`, applicationId), data, options);
+  }
+  async unassignAgent(taskId, agentId, applicationId, options) {
+    return this.del(this.withAppId(`/tasks/${taskId}/assign/${agentId}`, applicationId), options);
+  }
+  // History
+  async listAttempts(taskId, applicationId, options) {
+    const result = await this._get(
+      this.withAppId(`/tasks/${taskId}/attempts`, applicationId),
+      options
+    );
+    return { data: result.data?.attempts ?? [], error: result.error };
+  }
+  async listTransitions(taskId, applicationId, options) {
+    const result = await this._get(
+      this.withAppId(`/tasks/${taskId}/transitions`, applicationId),
+      options
+    );
+    return { data: result.data?.transitions ?? [], error: result.error };
+  }
+  // Documents
+  async createDocument(projectId, data, applicationId, options) {
+    return this.post(this.withAppId(`/projects/${projectId}/documents`, applicationId), data, options);
+  }
+  async listDocuments(projectId, applicationId, options) {
+    const result = await this._get(
+      this.withAppId(`/projects/${projectId}/documents`, applicationId),
+      options
+    );
+    return { data: result.data?.documents ?? [], error: result.error };
+  }
+  async deleteDocument(documentId, applicationId, options) {
+    return this.del(this.withAppId(`/documents/${documentId}`, applicationId), options);
+  }
+  // Pipelines
+  async createPipeline(projectId, data, applicationId, options) {
+    return this.post(this.withAppId(`/projects/${projectId}/pipelines`, applicationId), data, options);
+  }
+  async listPipelines(projectId, applicationId, options) {
+    const result = await this._get(
+      this.withAppId(`/projects/${projectId}/pipelines`, applicationId),
+      options
+    );
+    return { data: result.data?.pipelines ?? [], error: result.error };
+  }
+  async createPipelineVersion(pipelineId, data, applicationId, options) {
+    return this.post(
+      this.withAppId(`/pipelines/${pipelineId}/versions`, applicationId),
+      data,
+      options
+    );
+  }
+  async listPipelineVersions(pipelineId, applicationId, options) {
+    const result = await this._get(
+      this.withAppId(`/pipelines/${pipelineId}/versions`, applicationId),
+      options
+    );
+    return { data: result.data?.versions ?? [], error: result.error };
+  }
+};
+
+// src/services/agent-tools.ts
+var AgentToolsService = class extends ServiceModule {
+  constructor() {
+    super(...arguments);
+    this.basePath = "/v1/agent-tools";
+  }
+  // Tools
+  async createTool(data, options) {
+    return this.post("/tools", data, options);
+  }
+  async listTools(params, options) {
+    return this._list("/tools", params, options);
+  }
+  async getTool(id, options) {
+    return this._get(`/tools/${id}`, options);
+  }
+  async createCapability(toolId, data, options) {
+    return this.post(`/tools/${toolId}/capabilities`, data, options);
+  }
+  async listCapabilities(toolId, options) {
+    return this._get(`/tools/${toolId}/capabilities`, options);
+  }
+  // Tool Integrations
+  async createIntegration(data, options) {
+    return this.post("/tool-integrations", data, options);
+  }
+  async listIntegrations(params, options) {
+    return this._list("/tool-integrations", params, options);
+  }
+  async updateIntegration(id, data, options) {
+    return this.patch(`/tool-integrations/${id}`, data, options);
+  }
+  // Credentials
+  async createCredential(data, options) {
+    return this.post("/credentials", data, options);
+  }
+  async listCredentials(params, options) {
+    return this._list("/credentials", params, options);
+  }
+  async updateCredential(id, data, options) {
+    return this.patch(`/credentials/${id}`, data, options);
+  }
+  async createScope(credentialId, data, options) {
+    return this.post(`/credentials/${credentialId}/scopes`, data, options);
+  }
+  async listScopes(credentialId, options) {
+    return this._get(`/credentials/${credentialId}/scopes`, options);
+  }
+  // Entitlements
+  async grantEntitlement(data, options) {
+    return this.post("/agent-tool-entitlements", data, options);
+  }
+  async listEntitlements(params, options) {
+    return this._list("/agent-tool-entitlements", params, options);
+  }
+  async revokeEntitlement(id, options) {
+    return this.del(`/agent-tool-entitlements/${id}`, options);
+  }
+  async authorizeAction(data, options) {
+    return this.post("/authorize-action", data, options);
+  }
+  // Data Sources
+  async createDataSource(data, options) {
+    return this.post("/data-sources", data, options);
+  }
+  async listDataSources(params, options) {
+    return this._list("/data-sources", params, options);
+  }
+  // Data Access Policies
+  async createDataAccessPolicy(data, options) {
+    return this.post("/data-access-policies", data, options);
+  }
+  async listDataAccessPolicies(params, options) {
+    return this._list("/data-access-policies", params, options);
+  }
+};
+
+// src/services/agent-models.ts
+var AgentModelsService = class extends ServiceModule {
+  constructor() {
+    super(...arguments);
+    this.basePath = "/v1/agent-models";
+  }
+  // Providers
+  async createProvider(data, options) {
+    return this.post("/model-providers", data, options);
+  }
+  async listProviders(params, options) {
+    return this._list("/model-providers", params, options);
+  }
+  // Models
+  async createModel(data, options) {
+    return this.post("/models", data, options);
+  }
+  async listModels(params, options) {
+    return this._list("/models", params, options);
+  }
+  async getModel(id, options) {
+    return this._get(`/models/${id}`, options);
+  }
+  async createPricing(modelId, data, options) {
+    return this.post(`/models/${modelId}/pricing`, data, options);
+  }
+  async listPricing(modelId, options) {
+    return this._get(`/models/${modelId}/pricing`, options);
+  }
+  // Entitlements
+  async createEntitlement(data, options) {
+    return this.post("/model-entitlements", data, options);
+  }
+  async listEntitlements(params, options) {
+    return this._list("/model-entitlements", params, options);
+  }
+  async deleteEntitlement(id, options) {
+    return this.del(`/model-entitlements/${id}`, options);
+  }
+  // Usage & Reporting
+  async recordUsage(data, options) {
+    return this.post("/usage-records", data, options);
+  }
+  async listUsage(params, options) {
+    return this._list("/usage-records", params, options);
+  }
+  async getUsageSummary(params, options) {
+    return this._get(this.withQuery("/usage-records/summary", params), options);
+  }
+  async getCostReport(params, options) {
+    return this._get(this.withQuery("/cost-report", params), options);
+  }
+};
+
+// src/services/agent-sessions.ts
+var AgentSessionsService = class extends ServiceModule {
+  constructor() {
+    super(...arguments);
+    this.basePath = "/v1/agent-sessions";
+  }
+  // Sessions
+  async createSession(data, options) {
+    return this.post("/sessions", data, options);
+  }
+  async listSessions(params, options) {
+    return this._list("/sessions", params, options);
+  }
+  async getSession(id, options) {
+    return this._get(`/sessions/${id}`, options);
+  }
+  async startSession(id, options) {
+    return this.post(`/sessions/${id}/start`, void 0, options);
+  }
+  async endSession(id, data, options) {
+    return this.post(`/sessions/${id}/end`, data, options);
+  }
+  // Logs
+  async appendLog(sessionId, data, options) {
+    return this.post(`/sessions/${sessionId}/logs`, data, options);
+  }
+  async listLogs(sessionId, options) {
+    return this._get(`/sessions/${sessionId}/logs`, options);
+  }
+  // Artifacts
+  async addArtifact(sessionId, data, options) {
+    return this.post(`/sessions/${sessionId}/artifacts`, data, options);
+  }
+  async listArtifacts(sessionId, options) {
+    return this._get(`/sessions/${sessionId}/artifacts`, options);
+  }
+};
+
 // src/index.ts
 var ScaleMule = class {
   constructor(config) {
@@ -4197,6 +4748,12 @@ var ScaleMule = class {
     this.flagContent = new FlagContentService(this._client);
     this.compliance = new ComplianceService(this._client);
     this.orchestrator = new OrchestratorService(this._client);
+    this.agentAuth = new AgentAuthService(this._client);
+    this.agents = new AgentsService(this._client);
+    this.agentProjects = new AgentProjectsService(this._client);
+    this.agentTools = new AgentToolsService(this._client);
+    this.agentModels = new AgentModelsService(this._client);
+    this.agentSessions = new AgentSessionsService(this._client);
   }
   /**
    * Initialize the client — loads persisted session from storage.
@@ -4248,6 +4805,12 @@ var ScaleMule = class {
 var index_default = ScaleMule;
 export {
   AccountsService,
+  AgentAuthService,
+  AgentModelsService,
+  AgentProjectsService,
+  AgentSessionsService,
+  AgentToolsService,
+  AgentsService,
   AnalyticsService,
   AuthService,
   BillingService,