@eyepop.ai/eyepop 3.14.6 → 3.15.0

package/dist/eyepop.index.js

@@ -8695,6 +8695,7 @@ __export(index_exports, {
   Semaphore: () => Semaphore,
   SessionStatus: () => SessionStatus,
   Stream: () => Stream,
+  TaskMode: () => TaskMode,
   TaskType: () => TaskType,
   TranscodeMode: () => TranscodeMode,
   TransientPopId: () => TransientPopId,
@@ -10598,8 +10599,10 @@ var _WorkerEndpoint = class _WorkerEndpoint extends Endpoint {
   }
   async reconnect() {
     if (this.options().popId == "transient" /* Transient */) {
-      await this.startComputeSession();
+      await this.getComputeSession();
       this._pipelineId = await this.startTransientPipeline();
+    } else if (this.options().sessionUuid) {
+      await this.getComputeSession();
     } else {
       await this.startWebApiSessionWithPopId();
     }
@@ -10694,17 +10697,52 @@ var _WorkerEndpoint = class _WorkerEndpoint extends Endpoint {
       }
     }
   }
-  async startComputeSession() {
+  async getComputeSession() {
     if (!this._client) {
       throw new Error("endpoint not initialized");
     }
+    let session;
+    let headers;
+    const sessionUuid = this.options().sessionUuid;
+    if (sessionUuid) {
+      [session, headers] = await this.getPermanentComputeSession(this._client, sessionUuid);
+    } else {
+      [session, headers] = await this.getOnDemandComputeSession(this._client);
+    }
+    let isReady = false;
+    const deadline = Date.now() + _WorkerEndpoint.WAIT_FOR_IS_READY;
+    while (!isReady) {
+      const health_url = `${session.session_endpoint}/health`;
+      const response = await this._client.fetch(health_url, {
+        headers
+      });
+      if (response.status < 300) {
+        isReady = true;
+      } else if (Date.now() > deadline) {
+        throw new Error(`Created session ${session.session_uuid} did not become healthy after ${_WorkerEndpoint.WAIT_FOR_IS_READY / 1e3} seconds`);
+      } else {
+        this._logger.debug(`session ${session.session_uuid} health check status ${response.status}, wait and poll for update`);
+        await sleep(_WorkerEndpoint.CHECK_FOR_IS_READY_INTERVAL);
+      }
+    }
+    this._baseUrl = session.session_endpoint;
+    this._pipeline = null;
+    if (session.pipeline_uuid) {
+      this._pipelineId = session.pipeline_uuid;
+    } else if (session.pipelines) {
+      this._pipelineId = session.pipelines[0].pipeline_id;
+    } else {
+      this._pipelineId = null;
+    }
+  }
+  async getOnDemandComputeSession(httpClient) {
     let session = null;
     const sessionsUrl = `${this.eyepopUrl()}/v1/sessions`;
     this._requestLogger.debug("fetching sessions from: %s", sessionsUrl);
     const headers = {
       Authorization: await this.authorizationHeader()
     };
-    let response = await this._client.fetch(sessionsUrl, {
+    let response = await httpClient.fetch(sessionsUrl, {
       headers
     });
     let sessions;
@@ -10718,11 +10756,10 @@ var _WorkerEndpoint = class _WorkerEndpoint extends Endpoint {
       const response_content = await response.json();
       sessions = response_content;
     }
-    console.log(sessions);
     if (sessions.length > 0) {
-      this._logger.debug(`User has ${sessions.length} sessions, inspecting for active session`);
+      this._logger.debug(`User has ${sessions.length} sessions, inspecting for usable session`);
       for (let s of sessions) {
-        if (!_WorkerEndpoint.SESSION_DEAD.has(s.session_status)) {
+        if (!_WorkerEndpoint.SESSION_DEAD.has(s.session_status) && !s.persistent) {
           session = s;
           this._logger.debug(`Use active session ${s.session_uuid} with pipeline ${s.pipeline_uuid}`);
           break;
@@ -10731,7 +10768,7 @@ var _WorkerEndpoint = class _WorkerEndpoint extends Endpoint {
     }
     if (!session) {
       this._requestLogger.debug("creating a new session at: %s", sessionsUrl);
-      response = await this._client.fetch(`${sessionsUrl}?wait=true`, {
+      response = await httpClient.fetch(`${sessionsUrl}?wait=true`, {
         headers,
         method: "POST"
       });
@@ -10750,29 +10787,30 @@ var _WorkerEndpoint = class _WorkerEndpoint extends Endpoint {
     if (!session) {
       throw new Error("unexpected undefined session");
     }
-    let isReady = false;
-    const deadline = Date.now() + _WorkerEndpoint.WAIT_FOR_IS_READY;
-    while (!isReady) {
-      const health_url = `${session.session_endpoint}/health`;
-      response = await this._client.fetch(health_url, {
-        headers
-      });
-      if (response.status < 300) {
-        isReady = true;
-      } else if (Date.now() > deadline) {
-        throw new Error(`Created session ${session.session_uuid} did not become healthy after ${_WorkerEndpoint.WAIT_FOR_IS_READY / 1e3} seconds`);
-      } else {
-        this._logger.debug(`session ${session.session_uuid} health check status ${response.status}, wait and poll for update`);
-        await sleep(_WorkerEndpoint.CHECK_FOR_IS_READY_INTERVAL);
-      }
-    }
-    this._baseUrl = session.session_endpoint;
-    this._pipeline = null;
-    if (session.pipeline_uuid) {
-      this._pipelineId = session.pipeline_uuid;
+    return [session, headers];
+  }
+  async getPermanentComputeSession(httpClient, sessionUuid) {
+    let session = null;
+    const sessionUrl = `${this.eyepopUrl()}/v1/sessions/${sessionUuid}`;
+    this._requestLogger.debug("fetching session from: %s", sessionUrl);
+    const headers = {
+      Authorization: await this.authorizationHeader()
+    };
+    let response = await httpClient.fetch(sessionUrl, {
+      headers
+    });
+    if (response.status == 404) {
+      this.updateState("Error" /* Error */);
+      throw new Error(`Unexpected status ${response.status} compute sessions ${sessionUuid} not found`);
+    } else if (response.status != 200) {
+      this.updateState("Error" /* Error */);
+      const message = await response.text();
+      throw new Error(`Unexpected status ${response.status} fetching compute sessions: ${message}`);
     } else {
-      this._pipelineId = null;
+      const response_content = await response.json();
+      session = response_content;
     }
+    return [session, headers];
   }
   async startTransientPipeline() {
     const client = this._client;
@@ -11078,6 +11116,11 @@ var TaskType = /* @__PURE__ */ ((TaskType2) => {
   TaskType2["classification"] = "classification";
   return TaskType2;
 })(TaskType || {});
+var TaskMode = /* @__PURE__ */ ((TaskMode2) => {
+  TaskMode2["image"] = "image";
+  TaskMode2["video"] = "video";
+  return TaskMode2;
+})(TaskMode || {});
 var VlmAbilityStatus = /* @__PURE__ */ ((VlmAbilityStatus2) => {
   VlmAbilityStatus2["in_progress"] = "in_progress";
   VlmAbilityStatus2["draft"] = "draft";
@@ -12185,7 +12228,10 @@ var EyePop;
         throw new Error("auth option or EYEPOP_API_KEY environment variable is required");
       }
     }
-    if (opts.popId === void 0) {
+    if (opts.sessionUuid === void 0) {
+      opts.sessionUuid = readEnv("EYEPOP_SESSION_UUID");
+    }
+    if (opts.popId === void 0 && opts.sessionUuid === void 0) {
       opts.popId = readEnv("EYEPOP_POP_ID") || "transient" /* Transient */;
     }
     if (opts.autoStart === void 0) {
@@ -12309,6 +12355,7 @@ var index_default = EyePop;
   Semaphore,
   SessionStatus,
   Stream,
+  TaskMode,
   TaskType,
   TranscodeMode,
   TransientPopId,