@eyepop.ai/eyepop 1.3.0 → 1.4.0

package/dist/eyepop.index.mjs

@@ -8648,7 +8648,7 @@ var Stream = class _Stream {
     this.iterator = iterator;
     this.controller = controller;
   }
-  static iterFromReadableStream(readableStream, controller) {
+  static iterFromReadableStream(readableStream, controller, eventHandler) {
     let consumed = false;
     async function* iterLines() {
       const lineDecoder = new LineDecoder();
@@ -8671,7 +8671,16 @@ var Stream = class _Stream {
       try {
         for await (const line of iterLines()) {
           if (done) continue;
-          if (line) yield JSON.parse(line);
+          if (line) {
+            const message = JSON.parse(line);
+            const event = message["event"];
+            if (event !== void 0) {
+              eventHandler(event).then(() => {
+              });
+            } else {
+              yield message;
+            }
+          }
         }
         done = true;
       } catch (e) {
@@ -8894,11 +8903,20 @@ var AbstractJob = class {
     if (!this._responseStream) {
       throw Error("logical bug");
     }
-    return Stream.iterFromReadableStream(this._responseStream, this._controller);
+    return Stream.iterFromReadableStream(
+      this._responseStream,
+      this._controller,
+      async (event) => {
+        return await this.onEvent(event);
+      }
+    );
   }
   async startJob() {
     return Promise.reject("abstract class");
   }
+  async onEvent(event) {
+    return Promise.resolve();
+  }
   start(done, status) {
     this._responseStream = new Promise(async (resolve, reject) => {
       try {
@@ -8964,50 +8982,126 @@ var UploadJob = class extends AbstractJob {
     super(params, getSession, client, requestLogger);
     this._uploadStream = stream;
     this._mimeType = mimeType;
+    this._needsFullDuplex = mimeType.startsWith("video/");
+  }
+  async onEvent(event) {
+    if (event.type == "prepared") {
+      if (!event.source_id) {
+        return Promise.reject("did not get a prepared sourceId to simulate full duplex");
+      }
+      const session = await this._getSession();
+      if (!session.baseUrl) {
+        return Promise.reject("session.baseUrl must not ne null");
+      }
+      let request;
+      const postUrl = `${session.baseUrl.replace(/\/+$/, "")}/pipelines/${session.pipelineId}/source?mode=queue&processing=async&sourceId=${event.source_id}`;
+      if (this._params) {
+        this._requestLogger.debug("before POST %s with multipart body because of params", postUrl);
+        const params = JSON.stringify(this._params);
+        const paramBlob = new Blob([params], { type: "application/json" });
+        const formData = new FormData();
+        formData.append("params", paramBlob);
+        formData.append("file", this._uploadStream);
+        const headers = {
+          "Authorization": `Bearer ${session.accessToken}`,
+          "Accept": "application/jsonl"
+        };
+        request = this._client.fetch(postUrl, {
+          headers,
+          method: "POST",
+          body: formData,
+          signal: this._controller.signal,
+          // @ts-ignore
+          duplex: "half"
+        });
+      } else {
+        this._requestLogger.debug("before POST %s with stream as body", postUrl);
+        const headers = {
+          "Authorization": `Bearer ${session.accessToken}`,
+          "Accept": "application/jsonl",
+          "Content-Type": this._mimeType
+        };
+        request = this._client.fetch(postUrl, {
+          headers,
+          method: "POST",
+          body: this._uploadStream,
+          signal: this._controller.signal,
+          // @ts-ignore
+          duplex: "half"
+        });
+      }
+      request.then(async (value) => {
+        if (value.status != 204) {
+          this._requestLogger.debug("unexpected status %d (%s) for POST %s ", value.status, await value.text(), postUrl);
+        }
+      }).catch((reason) => {
+        this._requestLogger.debug("error %v for POST %s ", reason, postUrl);
+      }).finally(() => {
+        this._requestLogger.debug("after POST %s ", postUrl);
+      });
+    }
+    return Promise.resolve();
   }
   async startJob() {
     const session = await this._getSession();
     if (!session.baseUrl) {
       return Promise.reject("session.baseUrl must not ne null");
     }
-    const postUrl = `${session.baseUrl.replace(/\/+$/, "")}/pipelines/${session.pipelineId}/source?mode=queue&processing=sync`;
     let response;
-    if (this._params) {
-      this._requestLogger.debug("before POST %s with multipart body because of params");
-      const params = JSON.stringify(this._params);
-      const paramBlob = new Blob([params], { type: "application/json" });
-      const formData = new FormData();
-      formData.append("params", paramBlob);
-      formData.append("file", this._uploadStream);
+    if (this._needsFullDuplex) {
+      const prepareUrl = `${session.baseUrl.replace(/\/+$/, "")}/pipelines/${session.pipelineId}/prepareSource?timeout=10s`;
       const headers = {
         "Authorization": `Bearer ${session.accessToken}`,
         "Accept": "application/jsonl"
       };
-      response = await this._client.fetch(postUrl, {
+      this._requestLogger.debug("before POST %s to prepare full duplex upload", prepareUrl);
+      response = await this._client.fetch(prepareUrl, {
         headers,
         method: "POST",
-        body: formData,
         signal: this._controller.signal,
         // @ts-ignore
         duplex: "half"
       });
-      this._requestLogger.debug("after POST %s with multipart body because of params");
+      this._requestLogger.debug("after POST %s to prepare full duplex upload", prepareUrl);
     } else {
-      this._requestLogger.debug("before POST %s with stream as body");
-      const headers = {
-        "Authorization": `Bearer ${session.accessToken}`,
-        "Accept": "application/jsonl",
-        "Content-Type": this._mimeType
-      };
-      response = await this._client.fetch(postUrl, {
-        headers,
-        method: "POST",
-        body: this._uploadStream,
-        signal: this._controller.signal,
-        // @ts-ignore
-        duplex: "half"
-      });
-      this._requestLogger.debug("after POST %s with stream as body");
+      const postUrl = `${session.baseUrl.replace(/\/+$/, "")}/pipelines/${session.pipelineId}/source?mode=queue&processing=sync`;
+      if (this._params) {
+        this._requestLogger.debug("before POST %s with multipart body because of params", postUrl);
+        const params = JSON.stringify(this._params);
+        const paramBlob = new Blob([params], { type: "application/json" });
+        const formData = new FormData();
+        formData.append("params", paramBlob);
+        formData.append("file", this._uploadStream);
+        const headers = {
+          "Authorization": `Bearer ${session.accessToken}`,
+          "Accept": "application/jsonl"
+        };
+        response = await this._client.fetch(postUrl, {
+          headers,
+          method: "POST",
+          body: formData,
+          signal: this._controller.signal,
+          // @ts-ignore
+          duplex: "half"
+        });
+        this._requestLogger.debug("after POST %s with multipart body because of params", postUrl);
+      } else {
+        this._requestLogger.debug("before POST %s with stream as body", postUrl);
+        const headers = {
+          "Authorization": `Bearer ${session.accessToken}`,
+          "Accept": "application/jsonl",
+          "Content-Type": this._mimeType
+        };
+        response = await this._client.fetch(postUrl, {
+          headers,
+          method: "POST",
+          body: this._uploadStream,
+          signal: this._controller.signal,
+          // @ts-ignore
+          duplex: "half"
+        });
+        this._requestLogger.debug("after POST %s with stream as body", postUrl);
+      }
     }
     return response;
   }
@@ -9550,18 +9644,39 @@ if ("document" in globalThis && "implementation" in globalThis.document) {
     throw new DOMException("resolving a path to a file is not supported in browser");
   };
 } else {
+  let iteratorToStream = function(iterator) {
+    return new ReadableStream({
+      async pull(controller) {
+        const { value, done } = await iterator.next();
+        if (done) {
+          controller.close();
+        } else {
+          controller.enqueue(new Uint8Array(value));
+        }
+      }
+    });
+  };
+  iteratorToStream2 = iteratorToStream;
+  async function* nodeStreamToIterator(stream) {
+    for await (const chunk of stream) {
+      yield chunk;
+    }
+  }
   resolvePath = async (source) => {
     const mime = require_mime_types();
     const filehandle = __require("node:fs/promises");
     const fd = await filehandle.open(source.path, "r");
     const stream = fd.createReadStream();
+    const iterator = nodeStreamToIterator(stream);
+    const webStream = iteratorToStream(iterator);
     const mimeType = mime.lookup(source.path) || "application/octet-stream";
     return {
-      stream,
+      stream: webStream,
       mimeType
     };
   };
 }
+var iteratorToStream2;
 
 // shims/http_client.ts
 var createHttpClient;
@@ -9596,7 +9711,9 @@ if ("document" in globalThis && "implementation" in globalThis.document) {
     const undici = __require("undici");
     const agent = new undici.Agent({
       keepAliveTimeout: 1e4,
-      connections: 5
+      connections: 5,
+      // two parallel streaming requests to the same host seem to deadlock with pipelining > 0
+      pipelining: 0
     });
     return new HttpClient2(agent);
   };
@@ -11320,7 +11437,7 @@ var EyePop;
     }
     if (typeof opts.auth.oAuth2 != "undefined") {
       if (typeof opts.auth.oAuth2 === "boolean") {
-        if (opts.eyepopUrl.startsWith("https://staging-api.eyepop.ai")) {
+        if (opts.eyepopUrl.startsWith("https://web-api.staging.eyepop.xyz")) {
           opts.auth = {
             oAuth2: {
               domain: "dev-eyepop.us.auth0.com",