@eyepop.ai/eyepop 3.15.0 → 3.16.0

package/dist/eyepop.index.js

@@ -9799,8 +9799,9 @@ if ("document" in globalThis && "implementation" in globalThis.document) {
   };
 } else {
   class NodeHttpClient {
-    constructor(agent, logger) {
+    constructor(agent, fetchFn, logger) {
       this._agent = agent;
+      this._fetch = fetchFn;
       this._logger = logger;
     }
     async fetch(input, init) {
@@ -9808,7 +9809,7 @@ if ("document" in globalThis && "implementation" in globalThis.document) {
       init.dispatcher = this._agent;
       const logLine = logLineFromRequest(input, init);
       this._logger.debug(`Node fetch() BEFORE ${logLine}`);
-      const response = await fetch(input, init);
+      const response = await this._fetch(input, init);
       this._logger.debug(`AFTER ${logLine} -> ${response.status}`);
       return response;
     }
@@ -9828,7 +9829,7 @@ if ("document" in globalThis && "implementation" in globalThis.document) {
       pipelining: 0
     });
     logger.debug("Using node fetch with undici agent as http client");
-    return new NodeHttpClient(agent, logger);
+    return new NodeHttpClient(agent, undici.fetch, logger);
   };
 }
 
@@ -10244,6 +10245,7 @@ var SessionStatus = /* @__PURE__ */ ((SessionStatus2) => {
   SessionStatus2["PIPELINE_OK"] = "pipeline_ok";
   SessionStatus2["PIPELINE_CHECKING"] = "pipeline_checking";
   SessionStatus2["PIPELINE_ERROR"] = "pipeline_error";
+  SessionStatus2["UPGRADING"] = "upgrading";
   return SessionStatus2;
 })(SessionStatus || {});
 var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
@@ -10254,7 +10256,10 @@ var _WorkerEndpoint = class _WorkerEndpoint extends Endpoint {
     this._baseUrl = null;
     this._pipelineId = null;
     this._popName = null;
+    this._sessionAccessToken = null;
+    this._sessionAccessTokenValidUntil = null;
     this._pipeline = null;
+    this._pipelineCreatePromise = null;
   }
   options() {
     return this._options;
@@ -10281,20 +10286,29 @@ var _WorkerEndpoint = class _WorkerEndpoint extends Endpoint {
     this._baseUrl = null;
   }
   async session() {
-    const session = await super.session();
-    if (this._baseUrl == null || this._pipelineId == null) {
+    let session = null;
+    if (this._baseUrl == null) {
       await this.reconnect();
-      if (this._baseUrl == null || this._pipelineId == null) {
+      if (this._baseUrl == null) {
         return Promise.reject("endpoint not connected");
       }
     }
+    if (this._sessionAccessToken) {
+      session = {
+        eyepopUrl: this.options().eyepopUrl,
+        accessToken: this._sessionAccessToken,
+        validUntil: this._sessionAccessTokenValidUntil || Number.MAX_VALUE
+      };
+    } else {
+      session = await super.session();
+    }
     return {
       eyepopUrl: session.eyepopUrl,
       accessToken: session.accessToken,
       validUntil: session.validUntil,
       popId: this.options().popId,
       baseUrl: this._baseUrl,
-      pipelineId: this._pipelineId,
+      pipelineId: this._pipelineId || void 0,
       authenticationHeaders: () => this._authenticationHeaders(session)
     };
   }
@@ -10304,11 +10318,14 @@ var _WorkerEndpoint = class _WorkerEndpoint extends Endpoint {
   pop() {
     if (this._pipeline) {
       return this._pipeline.pop || null;
-    } else {
-      return null;
     }
+    return this.options().pop || null;
   }
   async changePop(pop) {
+    if (this.options().popId == "transient" /* Transient */) {
+      await this.changeTransientPop(pop);
+      return;
+    }
     const client = this._client;
     const baseUrl = this._baseUrl;
     if (!baseUrl || !client) {
@@ -10331,6 +10348,7 @@ var _WorkerEndpoint = class _WorkerEndpoint extends Endpoint {
       const message = await response.text();
       throw new Error(`Unexpected status ${response.status}: ${message}`);
     }
+    this.options().pop = pop;
     if (this._pipeline) {
       this._pipeline.pop = pop;
     } else {
@@ -10345,6 +10363,10 @@ var _WorkerEndpoint = class _WorkerEndpoint extends Endpoint {
   _authenticationHeaders(session) {
     return this._options.auth.isLocal !== void 0 ? {} : { Authorization: `Bearer ${session.accessToken}` };
   }
+  /**
+   * @deprecated Pop ids are only retained for backwards compatibility.
+   * Configure transient sessions with `WorkerOptions.pop`.
+   */
   popId() {
     return this.options().popId || null;
   }
@@ -10390,6 +10412,7 @@ var _WorkerEndpoint = class _WorkerEndpoint extends Endpoint {
     }
   }
   async uploadFile(source, params) {
+    await this.ensureTransientPipelineStarted();
     if (!this._baseUrl || !this._pipelineId || !this._client || !this._limit) {
       return Promise.reject("endpoint not connected, use connect()");
     }
@@ -10422,6 +10445,7 @@ var _WorkerEndpoint = class _WorkerEndpoint extends Endpoint {
     }
   }
   async uploadStream(source, params) {
+    await this.ensureTransientPipelineStarted();
     if (!this._baseUrl || !this._pipelineId || !this._client || !this._limit) {
       return Promise.reject("endpoint not connected, use connect()");
     }
@@ -10454,6 +10478,7 @@ var _WorkerEndpoint = class _WorkerEndpoint extends Endpoint {
     }
   }
   async uploadPath(source, params) {
+    await this.ensureTransientPipelineStarted();
     if (!this._baseUrl || !this._pipelineId || !this._client || !this._limit) {
       throw new Error("endpoint not connected, use connect()");
     }
@@ -10500,6 +10525,7 @@ var _WorkerEndpoint = class _WorkerEndpoint extends Endpoint {
         params
       );
     }
+    await this.ensureTransientPipelineStarted();
     if (!this._baseUrl || !this._pipelineId || !this._client || !this._limit) {
       throw new Error("endpoint not connected, use connect()");
     }
@@ -10529,6 +10555,7 @@ var _WorkerEndpoint = class _WorkerEndpoint extends Endpoint {
     }
   }
   async loadFromAssetUuid(source, params) {
+    await this.ensureTransientPipelineStarted();
     if (!this._baseUrl || !this._pipelineId || !this._client || !this._limit) {
       throw new Error("endpoint not connected, use connect()");
     }
@@ -10558,6 +10585,7 @@ var _WorkerEndpoint = class _WorkerEndpoint extends Endpoint {
     }
   }
   async loadMediaStream(source, params) {
+    await this.ensureTransientPipelineStarted();
     if (!this._baseUrl || !this._pipelineId || !this._client || !this._limit) {
       throw new Error("endpoint not connected, use connect()");
     }
@@ -10600,7 +10628,9 @@ var _WorkerEndpoint = class _WorkerEndpoint extends Endpoint {
   async reconnect() {
     if (this.options().popId == "transient" /* Transient */) {
       await this.getComputeSession();
-      this._pipelineId = await this.startTransientPipeline();
+      if (this.options().pop) {
+        this.setTransientPipelinePop();
+      }
     } else if (this.options().sessionUuid) {
       await this.getComputeSession();
     } else {
@@ -10697,29 +10727,65 @@ var _WorkerEndpoint = class _WorkerEndpoint extends Endpoint {
       }
     }
   }
+  sessionReadyTimeoutMs() {
+    const seconds = this.options().sessionReadyTimeoutSeconds;
+    return typeof seconds == "number" && Number.isFinite(seconds) && seconds > 0 ? seconds * 1e3 : _WorkerEndpoint.WAIT_FOR_IS_READY;
+  }
+  sessionHealthReady(body, contentType) {
+    if (contentType.includes("application/json")) {
+      const health = JSON.parse(body);
+      if (health && typeof health == "object") {
+        if (health.message && !health.session_status) {
+          return true;
+        }
+        return health.session_status == "running" /* RUNNING */;
+      }
+    }
+    return contentType.includes("text/plain") && body.includes("I'm fine");
+  }
   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);
+      session = await this.getPermanentComputeSession(this._client, sessionUuid);
     } else {
-      [session, headers] = await this.getOnDemandComputeSession(this._client);
+      session = await this.getOnDemandComputeSession(this._client);
     }
+    this.setComputeSessionAccessToken(session);
+    const headers = {
+      Authorization: await this.authorizationHeader()
+    };
     let isReady = false;
-    const deadline = Date.now() + _WorkerEndpoint.WAIT_FOR_IS_READY;
+    const readyTimeoutMs = this.sessionReadyTimeoutMs();
+    const deadline = Date.now() + readyTimeoutMs;
     while (!isReady) {
       const health_url = `${session.session_endpoint}/health`;
       const response = await this._client.fetch(health_url, {
-        headers
+        headers: {
+          ...headers,
+          Accept: "application/json"
+        }
       });
-      if (response.status < 300) {
-        isReady = true;
+      if (response.status == 200) {
+        const contentType = response.headers.get("content-type") || "";
+        const body = await response.text();
+        try {
+          isReady = this.sessionHealthReady(body, contentType);
+        } catch (error) {
+          this._logger.debug(`session ${session.session_uuid} health check returned invalid JSON, wait and poll for update`);
+        }
+        if (!isReady && Date.now() > deadline) {
+          throw new Error(`Created session ${session.session_uuid} did not become healthy after ${readyTimeoutMs / 1e3} seconds`);
+        }
+        if (!isReady) {
+          this._logger.debug(`session ${session.session_uuid} health check not ready, wait and poll for update`);
+          await sleep(_WorkerEndpoint.CHECK_FOR_IS_READY_INTERVAL);
+        }
       } 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`);
+        throw new Error(`Created session ${session.session_uuid} did not become healthy after ${readyTimeoutMs / 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);
@@ -10727,51 +10793,59 @@ var _WorkerEndpoint = class _WorkerEndpoint extends Endpoint {
     }
     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;
+    this._pipelineId = this.pipelineIdFromSession(session);
+    if (this.options().pop) {
+      this.setTransientPipelinePop();
     }
   }
   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()
+      Authorization: await this.computeAuthorizationHeader()
     };
-    let response = await httpClient.fetch(sessionsUrl, {
-      headers
-    });
     let sessions;
-    if (response.status == 404) {
-      sessions = [];
-    } 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 {
-      const response_content = await response.json();
-      sessions = response_content;
-    }
-    if (sessions.length > 0) {
-      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) && !s.persistent) {
-          session = s;
-          this._logger.debug(`Use active session ${s.session_uuid} with pipeline ${s.pipeline_uuid}`);
-          break;
+    if (!this.options().pop) {
+      this._requestLogger.debug("fetching sessions from: %s", sessionsUrl);
+      const response = await httpClient.fetch(sessionsUrl, {
+        headers
+      });
+      if (response.status == 404) {
+        sessions = [];
+      } 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 {
+        const response_content = await response.json();
+        sessions = response_content;
+      }
+      if (sessions.length > 0) {
+        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) && !s.persistent) {
+            session = s;
+            this._logger.debug(`Use active session ${s.session_uuid} with pipeline ${this.pipelineIdFromSession(s)}`);
+            break;
+          }
         }
       }
     }
     if (!session) {
       this._requestLogger.debug("creating a new session at: %s", sessionsUrl);
-      response = await httpClient.fetch(`${sessionsUrl}?wait=true`, {
-        headers,
+      const createBody = this.sessionCreateBody();
+      const createHeaders = {
+        ...headers,
+        ...createBody ? { "Content-Type": "application/json" } : {}
+      };
+      const request = {
+        headers: createHeaders,
         method: "POST"
-      });
+      };
+      if (createBody) {
+        request.body = createBody;
+      }
+      const response = await httpClient.fetch(`${sessionsUrl}?wait=true`, request);
       if (response.status != 200) {
         this.updateState("Error" /* Error */);
         const message = await response.text();
@@ -10787,14 +10861,14 @@ var _WorkerEndpoint = class _WorkerEndpoint extends Endpoint {
     if (!session) {
       throw new Error("unexpected undefined session");
     }
-    return [session, headers];
+    return session;
   }
   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()
+      Authorization: await this.computeAuthorizationHeader()
     };
     let response = await httpClient.fetch(sessionUrl, {
       headers
@@ -10810,7 +10884,7 @@ var _WorkerEndpoint = class _WorkerEndpoint extends Endpoint {
       const response_content = await response.json();
       session = response_content;
     }
-    return [session, headers];
+    return session;
   }
   async startTransientPipeline() {
     const client = this._client;
@@ -10819,12 +10893,12 @@ var _WorkerEndpoint = class _WorkerEndpoint extends Endpoint {
       throw new Error("endpoint not initialized");
     }
     let pop;
-    if (this._pipeline && this._pipeline.pop) {
+    if (this.options().pop) {
+      pop = this.options().pop;
+    } else if (this._pipeline && this._pipeline.pop) {
       pop = this._pipeline.pop;
     } else {
-      pop = {
-        components: []
-      };
+      throw new Error("Cannot start a transient pipeline without a pop");
     }
     const body = {
       pop,
@@ -10836,8 +10910,9 @@ var _WorkerEndpoint = class _WorkerEndpoint extends Endpoint {
       videoOutput: "no_output"
     };
     const post_url = `${baseUrl.replace(/\/+$/, "")}/pipelines`;
-    let response = await this.fetchWithRetry(async () => {
+    const response = await this.fetchWithRetry(async () => {
       let headers = {
+        Accept: "application/json",
         "Content-Type": "application/json",
         Authorization: await this.authorizationHeader()
       };
@@ -10849,11 +10924,138 @@ var _WorkerEndpoint = class _WorkerEndpoint extends Endpoint {
     });
     if (response.status != 200) {
       const message = await response.text();
-      throw new Error(`Unexpected status ${response.status}: ${message}`);
+      throw new Error(`Unexpected status ${response.status} starting transient pipeline: ${message.slice(0, 300)}`);
     }
     const result = await response.json();
     return result["id"];
   }
+  async ensureTransientPipelineStarted() {
+    if (this.options().popId != "transient" /* Transient */ || this._pipelineId) {
+      return;
+    }
+    if (!this.options().pop) {
+      return;
+    }
+    if (!this._baseUrl) {
+      await this.reconnect();
+    }
+    if (this._pipelineId) {
+      return;
+    }
+    if (!this._pipelineCreatePromise) {
+      this._pipelineCreatePromise = this.startTransientPipeline();
+    }
+    try {
+      this._pipelineId = await this._pipelineCreatePromise;
+      this.setTransientPipelinePop();
+    } finally {
+      this._pipelineCreatePromise = null;
+    }
+  }
+  async changeTransientPop(pop) {
+    if (!this._client) {
+      throw new Error("endpoint not initialized");
+    }
+    const previousPop = this.options().pop;
+    const previousPipeline = this._pipeline;
+    if (this._pipelineId) {
+      await this.deleteTransientPipeline(this._pipelineId);
+      this._pipelineId = null;
+    }
+    this._pipeline = null;
+    try {
+      this.options().pop = pop;
+      await this.ensureTransientPipelineStarted();
+    } catch (error) {
+      this.options().pop = previousPop;
+      this._pipeline = previousPipeline;
+      throw error;
+    }
+    if (!this._pipelineId) {
+      throw new Error("Compute session did not provide a pipeline for the requested pop");
+    }
+    this.setTransientPipelinePop();
+  }
+  async deleteTransientPipeline(pipelineId) {
+    if (!this._client || !this._baseUrl) {
+      return;
+    }
+    const deleteUrl = `${this._baseUrl}/pipelines/${pipelineId}`;
+    const headers = {
+      Authorization: await this.authorizationHeader()
+    };
+    let response = await this._client.fetch(deleteUrl, {
+      method: "DELETE",
+      headers
+    });
+    if (response.status >= 300) {
+      const message = await response.text();
+      this._logger.info(`stopping pipeline failed, status ${response.status}: ${message}`);
+    }
+  }
+  pipelineIdFromSession(session) {
+    if (session.pipeline_uuid) {
+      return session.pipeline_uuid;
+    }
+    const pipeline = session.pipelines?.[0];
+    return pipeline?.id || pipeline?.pipeline_id || null;
+  }
+  async authorizationHeader() {
+    if (this._sessionAccessToken) {
+      return `Bearer ${this._sessionAccessToken}`;
+    }
+    return super.authorizationHeader();
+  }
+  async computeAuthorizationHeader() {
+    if (this.options().auth.isLocal !== void 0) {
+      return "Implicit";
+    }
+    if (this.options().auth.apiKey !== void 0) {
+      return `Bearer ${this.options().auth.apiKey}`;
+    }
+    return super.authorizationHeader();
+  }
+  setComputeSessionAccessToken(session) {
+    if (!session.access_token) {
+      throw new Error(`Compute session ${session.session_uuid} did not provide an access token`);
+    }
+    this._sessionAccessToken = session.access_token;
+    if (session.access_token_expires_at) {
+      const expiresAt = Date.parse(session.access_token_expires_at);
+      this._sessionAccessTokenValidUntil = Number.isNaN(expiresAt) ? null : expiresAt;
+    } else if (session.access_token_expires_in) {
+      this._sessionAccessTokenValidUntil = Date.now() + session.access_token_expires_in * 1e3;
+    } else {
+      this._sessionAccessTokenValidUntil = null;
+    }
+  }
+  setTransientPipelinePop() {
+    const pop = this.options().pop;
+    if (pop && this._pipelineId) {
+      this._pipeline = {
+        id: this._pipelineId,
+        state: "idle",
+        startTime: (/* @__PURE__ */ new Date()).toString(),
+        pop
+      };
+    }
+  }
+  sessionCreateBody() {
+    const body = {};
+    if (this.options().sessionName) {
+      body.session_name = this.options().sessionName;
+    }
+    if (this.options().pipelineImage) {
+      body.pipeline_image = this.options().pipelineImage;
+    }
+    if (this.options().pipelineVersion) {
+      body.pipeline_version = this.options().pipelineVersion;
+    }
+    if (this.options().pop) {
+      body.pop = this.options().pop;
+    }
+    return Object.keys(body).length > 0 ? JSON.stringify(body) : void 0;
+  }
 };
 _WorkerEndpoint.SESSION_DEAD = /* @__PURE__ */ new Set(["error" /* ERROR */, "failed" /* FAILED */, "stopped" /* STOPPED */, "pipeline_error" /* PIPELINE_ERROR */, "unknown" /* UNKNOWN */]);
 _WorkerEndpoint.WAIT_FOR_IS_READY = 60 * 1e3;
@@ -12231,6 +12433,15 @@ var EyePop;
     if (opts.sessionUuid === void 0) {
       opts.sessionUuid = readEnv("EYEPOP_SESSION_UUID");
     }
+    if (opts.sessionName === void 0) {
+      opts.sessionName = readEnv("EYEPOP_SESSION_NAME");
+    }
+    if (opts.pipelineImage === void 0) {
+      opts.pipelineImage = readEnv("EYEPOP_PIPELINE_IMAGE");
+    }
+    if (opts.pipelineVersion === void 0) {
+      opts.pipelineVersion = readEnv("EYEPOP_PIPELINE_VERSION");
+    }
     if (opts.popId === void 0 && opts.sessionUuid === void 0) {
       opts.popId = readEnv("EYEPOP_POP_ID") || "transient" /* Transient */;
     }