@eyepop.ai/eyepop 3.26.0-rc.1 → 3.26.0

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 NOT_EXCHANGEABLE = ["API key or user login required", "API key authentication required for token refresh"];
+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;
@@ -8951,7 +8962,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) {
@@ -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,75 @@ 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 to exchange
+   * (see NOT_EXCHANGEABLE), 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);
+      const refusal = response.status == 401 ? await response.clone().text() : "";
+      if (!NOT_EXCHANGEABLE.some((message) => refusal.includes(message))) {
+        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 +11727,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 +12320,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 +12888,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 +12925,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 +12956,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 {
@@ -13013,6 +13074,70 @@ function omit_nulls(_, value) {
   }
   return value;
 }
+var TASK_EXCLUDED_FIELDS = ["text_prompt", "transform_into", "response_schema"];
+var VlmAbilityModeErrorReason = /* @__PURE__ */ ((VlmAbilityModeErrorReason2) => {
+  VlmAbilityModeErrorReason2["missing_mode"] = "missing_mode";
+  VlmAbilityModeErrorReason2["unknown_task"] = "unknown_task";
+  VlmAbilityModeErrorReason2["task_excludes_free_form"] = "task_excludes_free_form";
+  VlmAbilityModeErrorReason2["task_without_prompts"] = "task_without_prompts";
+  VlmAbilityModeErrorReason2["prompts_without_task"] = "prompts_without_task";
+  VlmAbilityModeErrorReason2["empty_prompts"] = "empty_prompts";
+  VlmAbilityModeErrorReason2["invalid_prompt"] = "invalid_prompt";
+  return VlmAbilityModeErrorReason2;
+})(VlmAbilityModeErrorReason || {});
+var VlmAbilityModeError = class extends Error {
+  constructor(reason, message, fields = []) {
+    super(message);
+    this.name = "VlmAbilityModeError";
+    this.reason = reason;
+    this.fields = fields;
+  }
+};
+function isSet(value) {
+  return value !== void 0 && value !== null;
+}
+function validateVlmAbilityMode(ability, partial) {
+  const kind = partial ? "VLM ability update" : "VLM ability";
+  const taskSet = isSet(ability.task);
+  const promptsSet = isSet(ability.prompts);
+  if (taskSet && !Object.values(AutoAnnotateTask).includes(ability.task)) {
+    throw new VlmAbilityModeError("unknown_task" /* unknown_task */, `${kind}: unknown task '${String(ability.task)}', expected one of ${Object.values(AutoAnnotateTask).join(", ")}`, [
+      "task"
+    ]);
+  }
+  if (taskSet || promptsSet) {
+    const conflicting = TASK_EXCLUDED_FIELDS.filter((field) => isSet(ability[field]));
+    if (conflicting.length > 0) {
+      throw new VlmAbilityModeError(
+        "task_excludes_free_form" /* task_excludes_free_form */,
+        `${kind}: a task derives the prompt and output schema, so ${conflicting.join(", ")} must be unset with task and prompts`,
+        [...conflicting]
+      );
+    }
+  }
+  if (promptsSet) {
+    if (!Array.isArray(ability.prompts) || ability.prompts.length === 0) {
+      throw new VlmAbilityModeError("empty_prompts" /* empty_prompts */, `${kind}: prompts must be a non-empty list of {label, prompt}`, ["prompts"]);
+    }
+    ability.prompts.forEach((entry, i) => {
+      if (!entry || typeof entry.label !== "string" || entry.label.length === 0 || typeof entry.prompt !== "string" || entry.prompt.length === 0) {
+        throw new VlmAbilityModeError("invalid_prompt" /* invalid_prompt */, `${kind}: prompts[${i}] needs a non-empty label and prompt`, [`prompts[${i}]`]);
+      }
+    });
+  }
+  if (partial) {
+    return;
+  }
+  if (taskSet && !promptsSet) {
+    throw new VlmAbilityModeError("task_without_prompts" /* task_without_prompts */, `${kind}: task '${ability.task}' requires a non-empty prompts list of {label, prompt}`, ["prompts"]);
+  }
+  if (!taskSet && promptsSet) {
+    throw new VlmAbilityModeError("prompts_without_task" /* prompts_without_task */, `${kind}: prompts are only used with a task; set task, or use text_prompt for a free-form ability`, ["prompts"]);
+  }
+  if (!taskSet && !(typeof ability.text_prompt === "string" && ability.text_prompt.length > 0)) {
+    throw new VlmAbilityModeError("missing_mode" /* missing_mode */, `${kind}: set either text_prompt (free-form) or task with non-empty prompts`, ["text_prompt", "task"]);
+  }
+}
 var DataEndpoint = class extends Endpoint {
   constructor(options) {
     super(options);
@@ -13804,6 +13929,7 @@ var DataEndpoint = class extends Endpoint {
     });
   }
   async createVlmAbility(create, vlm_ability_group_uuid) {
+    validateVlmAbilityMode(create, false);
     const groupQuery = vlm_ability_group_uuid ? `&vlm_ability_group_uuid=${vlm_ability_group_uuid}` : "";
     return this.request(`/vlm_abilities?account_uuid=${this._accountId}${groupQuery}`, {
       method: "POST",
@@ -13822,6 +13948,7 @@ var DataEndpoint = class extends Endpoint {
     });
   }
   async updateVlmAbility(vlm_ability_uuid, update) {
+    validateVlmAbilityMode(update, true);
     return this.request(`/vlm_abilities/${vlm_ability_uuid}`, {
       method: "PATCH",
       body: JSON.stringify(update),
@@ -14420,17 +14547,17 @@ var EyePop;
         if (typeof auth.oAuth2 === "boolean") {
           const oAuth2 = opts.eyepopUrl && opts.eyepopUrl.match(/https:(.*).staging.eyepop.xyz/i) ? {
             oAuth2: {
-              domain: "dev-eyepop.us.auth0.com",
+              domain: "auth0.eyepop.xyz",
               clientId: "jktx3YO2UnbkNPvr05PQWf26t1kNTJyg",
               audience: "https://dev-app.eyepop.ai",
-              scope: "admin:clouds access:inference-api access:datasets"
+              scope: "access:inference-api access:datasets"
             }
           } : {
             oAuth2: {
-              domain: "eyepop.us.auth0.com",
+              domain: "auth0.eyepop.ai",
               clientId: "Lb9ubA9Hf3jlaqWLUx8XgA0zvotgViCl",
               audience: "https://api.eyepop.ai",
-              scope: "admin:clouds access:inference-api access:datasets"
+              scope: "access:inference-api access:datasets"
             }
           };
           if (opts.oAuth2 !== void 0) {
@@ -14514,6 +14641,8 @@ export {
   UploadJob,
   UserReview,
   VideoMode,
+  VlmAbilityModeError,
+  VlmAbilityModeErrorReason,
   VlmAbilityStatus,
   WebrtcBase,
   WebrtcWhep,