@eyepop.ai/eyepop 3.25.4 → 3.25.5

package/dist/eyepop.index.mjs

@@ -8928,14 +8928,25 @@ if ("document" in globalThis && "implementation" in globalThis.document) {
 }
 
 // endpoint.ts
+var ACCOUNT_CLAIM = "https://ident.eyepop.ai/account-uuid";
+var M2M_REFUSAL = "API key or user login required";
+function carriesAccount(token) {
+  try {
+    const payload = (token.split(".")[1] ?? "").replace(/-/g, "+").replace(/_/g, "/");
+    return Boolean(JSON.parse(atob(payload))?.[ACCOUNT_CLAIM]);
+  } catch {
+    return false;
+  }
+}
 var Endpoint = class {
   constructor(options) {
+    this._exchanging = null;
     this._options = options;
     this._token = null;
     this._expire_token_time = null;
     this._client = null;
     this._statusRetryHandlers = /* @__PURE__ */ new Map();
-    this._statusRetryHandlers.set(401, (statusCode) => this.statusHandler401(statusCode));
+    this._statusRetryHandlers.set(401, (statusCode, failedToken) => this.statusHandler401(statusCode, failedToken));
     this._limit = new Semaphore(this._options.jobQueueLength ?? 1024);
     this._state = "Idle" /* Idle */;
     this._message = null;
@@ -8951,7 +8962,7 @@ var Endpoint = class {
   }
   setStatusRetryHandlers(statusRetryHandlers = void 0) {
     this._statusRetryHandlers = new Map(statusRetryHandlers);
-    this._statusRetryHandlers.set(401, (statusCode) => this.statusHandler401(statusCode));
+    this._statusRetryHandlers.set(401, (statusCode, failedToken) => this.statusHandler401(statusCode, failedToken));
   }
   eyepopUrl() {
     if (this._options.eyepopUrl) {
@@ -9048,12 +9059,15 @@ var Endpoint = class {
       validUntil: this._expire_token_time * 1e3
     };
   }
-  statusHandler401(_statusCode) {
-    this._token = null;
-    this._expire_token_time = null;
+  statusHandler401(_statusCode, failedToken = this._token) {
+    if (this._token === failedToken) {
+      this._token = null;
+      this._expire_token_time = null;
+    }
   }
   async fetchWithRetry(fetcher, retries = 1) {
     while (true) {
+      const sentToken = this._token ?? void 0;
       try {
         const response = await fetcher();
         if (response.ok) {
@@ -9061,7 +9075,7 @@ var Endpoint = class {
         } else {
           const handler = this._statusRetryHandlers.get(response.status);
           if (handler != null) {
-            handler(response.status);
+            handler(response.status, sentToken);
             if (retries--) {
               this._requestLogger.info("received %d response, retry", response.status);
             } else {
@@ -9095,54 +9109,74 @@ var Endpoint = class {
     }
     return `Bearer ${await this.currentAccessToken()}`;
   }
+  async exchange(client, credential, accountUuid) {
+    const query = accountUuid ? `?account_uuid=${encodeURIComponent(accountUuid)}` : "";
+    return await client.fetch(`${this.eyepopUrl()}/v1/auth/authenticate${query}`, {
+      method: "POST",
+      headers: { Authorization: `Bearer ${credential}` }
+    });
+  }
+  async storeExchangedToken(response, now) {
+    if (response.status != 200) {
+      const message = await response.text();
+      return Promise.reject(`Unexpected status ${response.status}: ${message}`);
+    }
+    const token = await response.json();
+    this._token = token.access_token;
+    this._expire_token_time = now + token.expires_in - 60;
+  }
+  /**
+   * A token that already carries an account, or that the compute API refuses as an exchanged
+   * token ("API key or user login required"), is used as is. Any other refusal is raised.
+   */
+  async exchangeLoginToken(client, loginToken, validUntil, now) {
+    if (!carriesAccount(loginToken)) {
+      const response = await this.exchange(client, loginToken, this._options.accountId);
+      if (response.status != 401 || !(await response.clone().text()).includes(M2M_REFUSAL)) {
+        await this.storeExchangedToken(response, now);
+        return;
+      }
+    }
+    this._token = loginToken;
+    this._expire_token_time = validUntil;
+  }
   async currentAccessToken() {
+    if (!this._token || this._expire_token_time < Date.now() / 1e3) {
+      this._exchanging ?? (this._exchanging = this.authenticate().finally(() => this._exchanging = null));
+      await this._exchanging;
+    }
+    this._logger.debug("using access token, valid for at least %d seconds", this._expire_token_time - Date.now() / 1e3);
+    return this._token;
+  }
+  async authenticate() {
     const now = Date.now() / 1e3;
-    if (!this._token || this._expire_token_time < now) {
-      this.updateState("Authenticating" /* Authenticating */);
-      try {
-        const auth = resolveAuth(this._options);
-        if (!this._client) {
-          return Promise.reject("endpoint not connected");
-        } else if (auth?.isLocal !== void 0) {
-          this._token = "implicit";
-          this._expire_token_time = Number.MAX_VALUE;
-        } else if (auth?.session !== void 0) {
-          return Promise.reject("temporary access token expired");
-        } else if (auth?.oAuth2 !== void 0 && this._options.eyepopUrl) {
-          const session = await authenticateBrowserSession(auth.oAuth2, this._options);
-          this._token = session.accessToken;
-          this._expire_token_time = session.validUntil / 1e3;
-        } else if (accessTokenCredential(auth) !== void 0) {
-          this._token = accessTokenCredential(auth);
-          this._expire_token_time = Number.MAX_VALUE;
-        } else if (this._options.eyepopUrl) {
-          const credential = apiKeyCredential(auth);
-          if (credential === void 0) {
-            return Promise.reject("no valid auth option");
-          }
-          const headers = { Authorization: `Bearer ${credential}` };
-          const post_url = `${this.eyepopUrl()}/v1/auth/authenticate`;
-          const response = await this._client.fetch(post_url, {
-            method: "POST",
-            headers
-          });
-          if (response.status != 200) {
-            const message = await response.text();
-            return Promise.reject(`Unexpected status ${response.status}: ${message}`);
-          }
-          const data = await response.json();
-          const token = data;
-          this._token = token.access_token;
-          this._expire_token_time = now + token.expires_in - 60;
-        } else {
+    this.updateState("Authenticating" /* Authenticating */);
+    try {
+      const auth = resolveAuth(this._options);
+      if (!this._client) {
+        return Promise.reject("endpoint not connected");
+      } else if (auth?.isLocal !== void 0) {
+        this._token = "implicit";
+        this._expire_token_time = Number.MAX_VALUE;
+      } else if (auth?.session !== void 0) {
+        return Promise.reject("temporary access token expired");
+      } else if (auth?.oAuth2 !== void 0 && this._options.eyepopUrl) {
+        const login = await authenticateBrowserSession(auth.oAuth2, this._options);
+        await this.exchangeLoginToken(this._client, login.accessToken, login.validUntil / 1e3, now);
+      } else if (accessTokenCredential(auth) !== void 0) {
+        await this.exchangeLoginToken(this._client, accessTokenCredential(auth), Number.MAX_VALUE, now);
+      } else if (this._options.eyepopUrl) {
+        const credential = apiKeyCredential(auth);
+        if (credential === void 0) {
           return Promise.reject("no valid auth option");
         }
-      } finally {
-        this.updateState();
+        await this.storeExchangedToken(await this.exchange(this._client, credential), now);
+      } else {
+        return Promise.reject("no valid auth option");
       }
+    } finally {
+      this.updateState();
     }
-    this._logger.debug("using access token, valid for at least %d seconds", this._expire_token_time - now);
-    return this._token;
   }
 };
 
@@ -11692,10 +11726,22 @@ var PipelineJob = class {
     this.openSource = null;
     // Stops the job's source on the pipeline, once it was sent.
     this.stopOnPipeline = null;
+    this._milliComputeUnits = void 0;
   }
   get cancelled() {
     return this._cancelled;
   }
+  /** The source's milli compute units: the latest total of its `usage` messages and its `end`. */
+  get milliComputeUnits() {
+    return this._milliComputeUnits;
+  }
+  /** Keep a usage's or an end's milliComputeUnits: each carries the source's total so far. */
+  noteMilliComputeUnits(message) {
+    const value = message["milliComputeUnits"];
+    if (Number.isInteger(value) && value >= 0) {
+      this._milliComputeUnits = value;
+    }
+  }
   command(id) {
     const command = { type: "setSource", id, ...this.source };
     if (this.params.componentParams !== void 0) {
@@ -12273,7 +12319,11 @@ var PipelineBackend = class {
         case "prediction":
           job.predicted(message["prediction"]);
           break;
+        case "usage":
+          job.noteMilliComputeUnits(message);
+          break;
         case "end":
+          job.noteMilliComputeUnits(message);
           if (message["reason"] === "eos") {
             return null;
           }
@@ -12837,6 +12887,7 @@ var InferAssetJob = class {
   constructor(assetUrl, inferRequest, vlmFetch, requestLogger) {
     this._response = null;
     this._runInfo = null;
+    this._milliComputeUnits = void 0;
     this._controller = new AbortController();
     this._vlmFetch = vlmFetch;
     this._assetUrl = assetUrl;
@@ -12873,6 +12924,13 @@ var InferAssetJob = class {
     }
     return iterator();
   }
+  /**
+   * The milli compute units vlm-server billed for the inference, 0 on a cache hit; undefined before it answered
+   * or when it reported none.
+   */
+  get milliComputeUnits() {
+    return this._milliComputeUnits;
+  }
   start(done) {
     this._response = new Promise(async (resolve, reject) => {
       try {
@@ -12897,6 +12955,8 @@ var InferAssetJob = class {
           const runInfo = response["run_info"];
           if (predictions) {
             this._runInfo = runInfo;
+            const used = response["milli_compute_units"] ?? response["compute_units"];
+            this._milliComputeUnits = typeof used === "number" ? used : void 0;
             resolve(predictions);
             break;
           } else {