@eyepop.ai/eyepop 3.17.0 → 3.17.2

package/dist/eyepop.index.mjs

@@ -8681,14 +8681,96 @@ function accessTokenValidUntil(session) {
   }
   return null;
 }
+function errorInfoMessage(errorInfo) {
+  return [errorInfo.code, errorInfo.message, errorInfo.details].filter((part) => typeof part == "string" && part.length > 0).join(": ");
+}
+function pipelineErrorMessage(session) {
+  if (session.pipeline_error) {
+    const message = errorInfoMessage(session.pipeline_error);
+    return message ? `Pipeline failed for compute session ${session.session_uuid}: ${message}` : `Pipeline failed for compute session ${session.session_uuid}`;
+  }
+  if (session.session_status == "pipeline_error" /* PIPELINE_ERROR */) {
+    return `Pipeline failed for compute session ${session.session_uuid}`;
+  }
+  return null;
+}
+async function responseErrorMessage(response) {
+  const contentType = response.headers.get("content-type") || "";
+  if (contentType.includes("application/json")) {
+    try {
+      const parsed = normalizedJsonValue(await response.clone().json());
+      const message2 = normalizedErrorMessage(parsed);
+      if (message2) {
+        return message2;
+      }
+    } catch (_) {
+    }
+  }
+  const body = await response.text();
+  const message = normalizedErrorMessage(body);
+  return message || body;
+}
+function normalizedJsonValue(value) {
+  if (typeof value == "string") {
+    try {
+      const parsed = JSON.parse(value);
+      return normalizedJsonValue(parsed);
+    } catch (_) {
+      const unescaped = value.replace(/\\"/g, '"');
+      if (unescaped != value) {
+        try {
+          const parsed = JSON.parse(unescaped);
+          return normalizedJsonValue(parsed);
+        } catch (_2) {
+        }
+      }
+      return value;
+    }
+  }
+  return value;
+}
+async function responseJson(response) {
+  return normalizedJsonValue(await response.json());
+}
+function normalizedErrorMessage(value) {
+  value = normalizedJsonValue(value);
+  if (typeof value == "string") {
+    return value;
+  }
+  if (!value || typeof value != "object") {
+    return null;
+  }
+  const record = value;
+  const normalizedError = normalizedJsonValue(record["error"]);
+  const errorMessage = normalizedErrorMessage(normalizedError) || (typeof normalizedError == "string" ? normalizedError : null);
+  const message = [record["code"], errorMessage, record["message"], record["details"]].filter((part) => typeof part == "string" && part.length > 0).join(": ");
+  if (message) {
+    return message;
+  }
+  if (record["pipeline_error"]) {
+    return normalizedErrorMessage(record["pipeline_error"]);
+  }
+  if (normalizedError && typeof normalizedError == "object") {
+    return normalizedErrorMessage(normalizedError);
+  }
+  try {
+    return JSON.stringify(value);
+  } catch (_) {
+    return null;
+  }
+}
 var ComputeSessionClient = class {
   constructor(options) {
     this.options = options;
   }
   async resolve() {
     const session = this.options.sessionUuid ? await this.getPermanentComputeSession(this.options.sessionUuid) : await this.getOnDemandComputeSession();
-    const accessToken = this.sessionAccessToken(session);
-    await this.waitUntilReady(session, accessToken);
+    const pipelineFailure = pipelineErrorMessage(session);
+    if (pipelineFailure) {
+      throw new Error(pipelineFailure);
+    }
+    const authorizationHeader = await this.sessionAuthorizationHeader(session);
+    await this.waitUntilReady(session, authorizationHeader);
     const pipelineId = pipelineIdFromSession(session);
     if (this.options.pop && !pipelineId) {
       throw new Error("Compute session did not provide a pipeline for the requested pop");
@@ -8696,7 +8778,7 @@ var ComputeSessionClient = class {
     return {
       session,
       pipelineId,
-      accessToken,
+      accessToken: session.access_token || null,
       accessTokenValidUntil: accessTokenValidUntil(session)
     };
   }
@@ -8715,10 +8797,10 @@ var ComputeSessionClient = class {
       if (response.status == 404) {
         sessions = [];
       } else if (response.status != 200) {
-        const message = await response.text();
+        const message = await responseErrorMessage(response);
         throw new Error(`Unexpected status ${response.status} fetching compute sessions: ${message}`);
       } else {
-        const response_content = await response.json();
+        const response_content = await responseJson(response);
         sessions = response_content;
       }
       if (sessions.length > 0) {
@@ -8749,10 +8831,10 @@ var ComputeSessionClient = class {
       const query = "wait=true";
       const response = await this.options.httpClient.fetch(`${sessionsUrl}?${query}`, request);
       if (response.status != 200) {
-        const message = await response.text();
+        const message = await responseErrorMessage(response);
         throw new Error(`Unexpected status ${response.status} creating a compute session: ${message}`);
       } else {
-        sessions = await response.json();
+        sessions = await responseJson(response);
       }
       if (sessions.length == 0) {
         throw new Error("Unexpected, no compute session after attempt to create one");
@@ -8762,9 +8844,6 @@ var ComputeSessionClient = class {
     if (!session) {
       throw new Error("unexpected undefined session");
     }
-    if (this.options.pop && !pipelineIdFromSession(session)) {
-      throw new Error("Compute session did not provide a pipeline for the requested pop");
-    }
     return session;
   }
   async getPermanentComputeSession(sessionUuid) {
@@ -8780,28 +8859,28 @@ var ComputeSessionClient = class {
     if (response.status == 404) {
       throw new Error(`Unexpected status ${response.status} compute sessions ${sessionUuid} not found`);
     } else if (response.status != 200) {
-      const message = await response.text();
+      const message = await responseErrorMessage(response);
       throw new Error(`Unexpected status ${response.status} fetching compute sessions: ${message}`);
     } else {
-      const response_content = await response.json();
+      const response_content = await responseJson(response);
       session = response_content;
     }
     return session;
   }
-  sessionAccessToken(session) {
-    if (!session.access_token) {
-      throw new Error(`Compute session ${session.session_uuid} did not provide an access token`);
+  async sessionAuthorizationHeader(session) {
+    if (session.access_token) {
+      return `Bearer ${session.access_token}`;
     }
-    return session.access_token;
+    return this.options.authorizationHeader();
   }
-  async waitUntilReady(session, accessToken) {
+  async waitUntilReady(session, authorizationHeader) {
     let isReady = false;
     const deadline = Date.now() + this.options.readyTimeoutMs;
     while (!isReady) {
       const health_url = `${session.session_endpoint}/health`;
       const response = await this.options.httpClient.fetch(health_url, {
         headers: {
-          Authorization: `Bearer ${accessToken}`,
+          Authorization: authorizationHeader,
           Accept: "application/json"
         }
       });
@@ -9599,14 +9678,18 @@ var UploadJob = class extends AbstractJob {
   get [Symbol.toStringTag]() {
     return "uploadJob";
   }
-  constructor(stream, mimeType, size, videoMode, params, getSession, client, requestLogger) {
+  constructor(stream, mimeType, size, videoMode, params, getSession, client, requestLogger, uploadBodyFactory) {
     super(params, getSession, client, requestLogger);
     this._uploadStream = stream;
+    this._uploadBodyFactory = uploadBodyFactory;
     this._mimeType = mimeType;
     this._size = size;
     this._videoMode = videoMode;
     this._needsFullDuplex = !client.isFullDuplex() && mimeType.startsWith("video/") && videoMode == "stream" /* STREAM */;
   }
+  async uploadBody() {
+    return this._uploadBodyFactory ? await this._uploadBodyFactory() : this._uploadStream;
+  }
   async onEvent(event) {
     if (event.type == "prepared") {
       if (!event.source_id) {
@@ -9648,7 +9731,7 @@ var UploadJob = class extends AbstractJob {
           const blob = new Blob([JSON.stringify(this._params.fps)], { type: "application/json" });
           formData.append("fps", blob);
         }
-        const fileBlob = await new Response(this._uploadStream).blob();
+        const fileBlob = await new Response(await this.uploadBody()).blob();
         formData.append("file", fileBlob);
         const headers = {
           ...session.authenticationHeaders(),
@@ -9675,7 +9758,7 @@ var UploadJob = class extends AbstractJob {
         request = this._client.fetch(postUrl, {
           headers,
           method: "POST",
-          body: this._uploadStream,
+          body: await this.uploadBody(),
           signal: this._controller.signal,
           // @ts-ignore
           duplex: "half",
@@ -9743,7 +9826,7 @@ var UploadJob = class extends AbstractJob {
           const blob = new Blob([JSON.stringify(this._params.fps)], { type: "application/json" });
           formData.append("fps", blob);
         }
-        const fileBlob = await new Response(this._uploadStream).blob();
+        const fileBlob = await new Response(await this.uploadBody()).blob();
         formData.append("file", fileBlob);
         const headers = {
           ...session.authenticationHeaders(),
@@ -9770,7 +9853,7 @@ var UploadJob = class extends AbstractJob {
         response = await this._client.fetch(postUrl, {
           headers,
           method: "POST",
-          body: this._uploadStream,
+          body: await this.uploadBody(),
           signal: this._controller.signal,
           // @ts-ignore
           duplex: "half"
@@ -10870,12 +10953,21 @@ var _WorkerEndpoint = class _WorkerEndpoint extends Endpoint {
     await this._limit.acquire();
     try {
       this.updateState();
-      let streamSource;
-      if (this._options.platformSupport?.resolvePath) {
-        streamSource = await this._options.platformSupport.resolvePath(source, this._logger);
-      } else {
-        streamSource = await resolvePath(source, this._logger);
-      }
+      const resolveStreamSource = async () => {
+        if (this._options.platformSupport?.resolvePath) {
+          return await this._options.platformSupport.resolvePath(source, this._logger);
+        }
+        return await resolvePath(source, this._logger);
+      };
+      const streamSource = await resolveStreamSource();
+      let firstStreamPending = true;
+      const uploadBodyFactory = async () => {
+        if (firstStreamPending) {
+          firstStreamPending = false;
+          return streamSource.stream;
+        }
+        return (await resolveStreamSource()).stream;
+      };
       const job = new UploadJob(
         streamSource.stream,
         streamSource.mimeType,
@@ -10886,7 +10978,8 @@ var _WorkerEndpoint = class _WorkerEndpoint extends Endpoint {
           return this.session();
         },
         this._client,
-        this._requestLogger
+        this._requestLogger,
+        uploadBodyFactory
       );
       return job.start(
         () => {