@eyepop.ai/eyepop 3.25.3 → 3.25.5

package/dist/eyepop.index.js

@@ -8698,6 +8698,7 @@ __export(index_exports, {
   ModelType: () => ModelType,
   MotionModel: () => MotionModel,
   PIPELINE_PATH: () => PIPELINE_PATH,
+  PIPELINE_SOCKETS: () => PIPELINE_SOCKETS,
   PipelineBackend: () => PipelineBackend,
   PipelineCommandError: () => PipelineCommandError,
   PipelineConfigurationError: () => PipelineConfigurationError,
@@ -9043,14 +9044,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, this.statusHandler401);
+    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;
@@ -9066,7 +9078,7 @@ var Endpoint = class {
   }
   setStatusRetryHandlers(statusRetryHandlers = void 0) {
     this._statusRetryHandlers = new Map(statusRetryHandlers);
-    this._statusRetryHandlers.set(401, this.statusHandler401);
+    this._statusRetryHandlers.set(401, (statusCode, failedToken) => this.statusHandler401(statusCode, failedToken));
   }
   eyepopUrl() {
     if (this._options.eyepopUrl) {
@@ -9163,12 +9175,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) {
@@ -9176,7 +9191,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 {
@@ -9210,54 +9225,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;
   }
 };
 
@@ -11612,6 +11647,8 @@ if (isBrowser) {
 var PIPELINE_PATH = "/api/v1/pipeline";
 var SUBPROTOCOL = "eyepop.v1";
 var MAX_OPEN_SOURCES = 256;
+var PIPELINE_SOCKETS = 4;
+var EXTRA_SOCKET_RETRY_MS = 10 * 1e3;
 var COMBINED_UPLOAD_MAX_BYTES = 8 * 1024 * 1024;
 var CHUNK = 1;
 var COMBINED = 2;
@@ -11731,6 +11768,8 @@ var PipelineSocket = class {
     // The ids of sources sent on this socket that have neither ended nor been refused, as the
     // pipeline API counts them, cancelled ones included.
     this.held = /* @__PURE__ */ new Set();
+    // The held sources that are live. A live source never ends, so nothing queued behind it plays.
+    this.lives = /* @__PURE__ */ new Set();
     // The held sources the pipeline API took: only these end, so only these make room.
     this.accepted = /* @__PURE__ */ new Set();
     // The ends on this socket so far.
@@ -11739,6 +11778,7 @@ var PipelineSocket = class {
     // the next send waits. Null once none is held.
     this.cap = null;
     this._roomWaiters = [];
+    this.heartbeat = null;
     this.closed = new Promise((resolve) => this._markClosed = resolve);
   }
   /** A source ended or the socket closed: wake the send waiting for room. */
@@ -11772,6 +11812,10 @@ var PipelineSocket = class {
     return !this._closed && this.ws.readyState === 1;
   }
   markClosed() {
+    if (this.heartbeat !== null) {
+      clearInterval(this.heartbeat);
+      this.heartbeat = null;
+    }
     this._closed = true;
     this._markClosed();
     this.freed();
@@ -11798,10 +11842,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) {
@@ -11860,14 +11916,14 @@ var PipelineBackend = class {
   constructor(ctx) {
     this.ctx = ctx;
     this._pipelineApiUrl = null;
-    this._socket = null;
+    this._sockets = [];
     this._connecting = null;
     // Every job's setSource and every changePop goes out through this chain, in the order submitted.
     this._sendChain = Promise.resolve();
     this._disconnecting = false;
     this._nextId = 0;
     this._warned = /* @__PURE__ */ new Set();
-    this._heartbeat = null;
+    this._noExtraSocketUntil = 0;
     // Reconnects at once since a source last played.
     this._reconnects = 0;
     this._currentPop = ctx.options.pop ?? null;
@@ -11881,13 +11937,9 @@ var PipelineBackend = class {
   async disconnect(closeEndpoint) {
     await closeEndpoint();
     this._disconnecting = true;
-    if (this._heartbeat !== null) {
-      clearInterval(this._heartbeat);
-      this._heartbeat = null;
-    }
-    const socket = this._socket;
-    this._socket = null;
-    if (socket !== null) {
+    const sockets = this._sockets;
+    this._sockets = [];
+    for (const socket of sockets) {
       socket.ws.close(1e3);
       await socket.closed;
     }
@@ -11905,21 +11957,55 @@ var PipelineBackend = class {
     this._sendChain = result.catch(() => void 0);
     return result;
   }
-  /** The open socket, or a new one with the last pop set on it. */
+  openSockets() {
+    return this._sockets.filter((socket) => socket.open);
+  }
+  /** An open socket, or a new one with the last pop set on it. */
   async ensureSocket() {
-    if (this._socket !== null && this._socket.open) {
-      return this._socket;
+    const open = this.openSockets()[0];
+    if (open !== void 0) {
+      return open;
     }
     if (this._connecting === null) {
-      this._connecting = this.openSocket().finally(() => this._connecting = null);
+      this._connecting = this.openSocket(true).finally(() => this._connecting = null);
     }
     return await this._connecting;
   }
-  async openSocket() {
+  /**
+   * The socket for the next job; the caller runs it in submission order. A live job goes on a socket
+   * of its own, an idle one or a new one, which `pipelineSockets` does not count. Any other job skips
+   * the sockets with a live source: a new one while every other socket has a source and fewer than
+   * `pipelineSockets` are open, else the one with room and the fewest sources.
+   */
+  async socketForJob(job) {
+    if (job.live) {
+      return this.openSockets().find((socket) => socket.held.size === 0) ?? await this.openSocket(true);
+    }
+    const sockets = this.openSockets().filter((socket) => socket.lives.size === 0);
+    if (sockets.length === 0) {
+      return await this.openSocket(true);
+    }
+    if (sockets.length < (this.ctx.options.pipelineSockets ?? PIPELINE_SOCKETS) && sockets.every((socket) => socket.held.size > 0) && Date.now() >= this._noExtraSocketUntil) {
+      try {
+        return await this.openSocket(false);
+      } catch (error) {
+        this._noExtraSocketUntil = Date.now() + EXTRA_SOCKET_RETRY_MS;
+        this.ctx.requestLogger.info("could not open another pipeline API socket: %s", error);
+      }
+    }
+    const rank = (socket) => (socket.hasRoom ? 0 : MAX_OPEN_SOURCES + 1) + socket.held.size;
+    return sockets.reduce((best, socket) => rank(socket) < rank(best) ? socket : best);
+  }
+  /** A new socket with the last pop set on it; `patient` waits through 503 with Retry-After. */
+  async openSocket(patient) {
     if (this.ctx.client() === null) {
       throw new PipelineSocketClosedError(void 0, "the endpoint is not connected");
     }
-    const ws = await this.upgrade(await this.socketUrl());
+    const ws = await this.upgrade(await this.socketUrl(), patient);
+    if (this._disconnecting) {
+      ws.close(1e3);
+      throw new PipelineSocketClosedError(void 0, "the endpoint disconnected");
+    }
     const socket = new PipelineSocket(ws);
     ws.onmessage = (event) => {
       if (typeof event.data === "string") {
@@ -11933,31 +12019,29 @@ var PipelineBackend = class {
     ws.onerror = () => {
     };
     ws.onclose = (event) => this.closed(socket, event.code, event.reason);
-    this._socket = socket;
-    this.startHeartbeat(ws);
+    this._sockets.push(socket);
+    this.startHeartbeat(socket);
     if (this._currentPop !== null) {
       try {
         await this.setPopOn(socket, this._currentPop);
       } catch (error) {
-        this._socket = null;
+        this._sockets = this._sockets.filter((other) => other !== socket);
         ws.close(1e3);
         throw error;
       }
     }
     return socket;
   }
-  startHeartbeat(ws) {
-    if (this._heartbeat !== null) {
-      clearInterval(this._heartbeat);
-    }
+  startHeartbeat(socket) {
+    const ws = socket.ws;
     const ping = ws.ping;
     if (typeof ping === "function") {
-      this._heartbeat = setInterval(() => {
+      socket.heartbeat = setInterval(() => {
         if (ws.readyState === 1) {
           ping.call(ws);
         }
       }, HEARTBEAT_MS);
-      this._heartbeat.unref?.();
+      socket.heartbeat.unref?.();
     }
   }
   async socketUrl() {
@@ -11995,7 +12079,7 @@ var PipelineBackend = class {
     return (await this.ctx.credentialHeader()).replace(/^Bearer /, "");
   }
   /** Open the socket, waiting through 503 with Retry-After and exchanging the API key again after a 401. */
-  async upgrade(url) {
+  async upgrade(url, patient) {
     const deadline = Date.now() + MAX_RETRY_MS;
     let rejected = false;
     while (true) {
@@ -12013,7 +12097,7 @@ var PipelineBackend = class {
           continue;
         }
         const wait = error.status === 503 && error.retryAfter !== void 0 ? Math.max(error.retryAfter, 1) * 1e3 : void 0;
-        if (wait === void 0 || Date.now() + wait > deadline) {
+        if (!patient || wait === void 0 || Date.now() + wait > deadline) {
           throw error;
         }
         this.ctx.requestLogger.info("the pipeline API answered 503, retrying in %d ms", wait);
@@ -12023,9 +12107,7 @@ var PipelineBackend = class {
   }
   closed(socket, code, reason) {
     socket.markClosed();
-    if (this._socket === socket) {
-      this._socket = null;
-    }
+    this._sockets = this._sockets.filter((other) => other !== socket);
     const error = new PipelineSocketClosedError(code, reason);
     socket.sources.forEach((source) => source.close(error));
     socket.commands.forEach((command) => command.reject(error));
@@ -12051,12 +12133,14 @@ var PipelineBackend = class {
     const source = typeof id === "string" ? socket.sources.get(id) : void 0;
     if (type === "end") {
       socket.held.delete(id);
+      socket.lives.delete(id);
       socket.accepted.delete(id);
       socket.freed();
     } else if (type === "result" && socket.held.has(id)) {
       socket.accepted.add(id);
     } else if (type === "error" && message["error"] !== "unknown_command") {
       socket.held.delete(id);
+      socket.lives.delete(id);
       socket.wake();
     }
     if (type === "send" || type === "credit") {
@@ -12098,6 +12182,10 @@ var PipelineBackend = class {
   command(socket, message) {
     const id = this.newId(message["type"]);
     return new Promise((resolve, reject) => {
+      if (!socket.open) {
+        reject(new PipelineSocketClosedError(void 0, "the socket closed"));
+        return;
+      }
       socket.commands.set(id, { resolve, reject });
       socket.sendJson({ ...message, id });
     });
@@ -12106,15 +12194,28 @@ var PipelineBackend = class {
   pop() {
     return this._currentPop;
   }
-  /** Set the pop on the socket's pipeline; a pop it refuses rejects, and the last pop it took stays. */
+  /**
+   * Set the pop on every open socket's pipeline; a pop the first refuses rejects, and the last pop it
+   * took stays. shortcut: a refusal from a later socket, which the first took, leaves the earlier ones
+   * on the new pop; a refusal is the pop's own fault, so every socket answers it alike.
+   */
   async changePop(pop) {
     if (this.ctx.client() === null) {
       this._currentPop = pop;
       return;
     }
     await this.inOrder(async () => {
-      if (this._socket !== null && this._socket.open) {
-        await this.setPopOn(this._socket, pop);
+      const sockets = this.openSockets();
+      if (sockets.length > 0) {
+        for (const socket of sockets) {
+          try {
+            await this.setPopOn(socket, pop);
+          } catch (error) {
+            if (!(error instanceof PipelineSocketClosedError)) {
+              throw error;
+            }
+          }
+        }
         this._currentPop = pop;
         return;
       }
@@ -12275,22 +12376,30 @@ var PipelineBackend = class {
   }
   /** Send the job's setSource; the caller runs it in submission order. */
   async setSource(job) {
-    if (job.cancelled) {
-      return null;
-    }
-    let socket = await this.ensureSocket();
-    await socket.room(job);
     if (job.cancelled) {
       return null;
     }
     const combined = await combinedMedia(job);
-    socket = await this.ensureSocket();
+    let socket;
+    while (true) {
+      socket = await this.socketForJob(job);
+      await socket.room(job);
+      if (job.cancelled) {
+        return null;
+      }
+      if (socket.open) {
+        break;
+      }
+    }
     const source = new OpenSource(this.newId("source"));
     if (combined === null) {
       uploadKeys(job).forEach((key) => source.uploads.set(key, new Credit()));
     }
     socket.sources.set(source.id, source);
     socket.held.add(source.id);
+    if (job.live) {
+      socket.lives.add(source.id);
+    }
     source.endedBefore = socket.ended;
     job.openSource = source;
     job.stopOnPipeline = () => {
@@ -12326,7 +12435,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;
           }
@@ -12566,6 +12679,9 @@ var WorkerEndpoint = class extends Endpoint {
       if (options.jobQueueLength > MAX_OPEN_SOURCES) {
         throw new PipelineConfigurationError("job_queue_length", `jobQueueLength ${options.jobQueueLength} exceeds ${MAX_OPEN_SOURCES}, the open sources a pipeline API socket takes`);
       }
+      if (options.pipelineSockets !== void 0 && !(Number.isInteger(options.pipelineSockets) && options.pipelineSockets > 0)) {
+        throw new PipelineConfigurationError("pipeline_sockets", `pipelineSockets ${options.pipelineSockets} is not a positive whole number`);
+      }
     }
     super(options);
     const context = {
@@ -12887,6 +13003,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;
@@ -12923,6 +13040,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 {
@@ -12947,6 +13071,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 {
@@ -14541,6 +14667,7 @@ var index_default = EyePop;
   ModelType,
   MotionModel,
   PIPELINE_PATH,
+  PIPELINE_SOCKETS,
   PipelineBackend,
   PipelineCommandError,
   PipelineConfigurationError,