@botpress/cognitive 0.1.50 → 0.2.1

package/.turbo/turbo-build.log

@@ -1,28 +1,28 @@
 
-> @botpress/cognitive@0.1.50 build /home/runner/work/botpress/botpress/packages/cognitive
+> @botpress/cognitive@0.2.1 build /home/runner/work/botpress/botpress/packages/cognitive
 > pnpm build:type && pnpm build:neutral && size-limit
 
 
-> @botpress/cognitive@0.1.50 build:type /home/runner/work/botpress/botpress/packages/cognitive
+> @botpress/cognitive@0.2.1 build:type /home/runner/work/botpress/botpress/packages/cognitive
 > tsup --tsconfig tsconfig.build.json ./src/index.ts --dts-resolve --dts-only --clean
 
 CLI Building entry: ./src/index.ts
 CLI Using tsconfig: tsconfig.build.json
 CLI tsup v8.0.2
 DTS Build start
-DTS ⚡️ Build success in 9361ms
-DTS dist/index.d.ts 631.36 KB
+DTS ⚡️ Build success in 4315ms
+DTS dist/index.d.ts 632.56 KB
 
-> @botpress/cognitive@0.1.50 build:neutral /home/runner/work/botpress/botpress/packages/cognitive
+> @botpress/cognitive@0.2.1 build:neutral /home/runner/work/botpress/botpress/packages/cognitive
 > ts-node -T ./build.ts --neutral
 
 Done
   
   dist/index.cjs
   Size limit: 50 kB
-  Size:       14.74 kB brotlied
+  Size:       15.02 kB brotlied
   
   dist/index.mjs
   Size limit: 50 kB
-  Size:       14.58 kB brotlied
+  Size:       14.88 kB brotlied
   

package/dist/index.cjs

@@ -1763,6 +1763,7 @@ var CognitiveBeta = class _CognitiveBeta {
   _withCredentials;
   _headers;
   _debug = false;
+  _events = createNanoEvents();
   constructor(props) {
     this._apiUrl = props.apiUrl || "https://api.botpress.cloud";
     this._timeout = props.timeout || 60001;
@@ -1793,15 +1794,28 @@ var CognitiveBeta = class _CognitiveBeta {
       debug: this._debug
     });
   }
+  on(event, cb) {
+    return this._events.on(event, cb);
+  }
   async generateText(input, options = {}) {
     const signal = options.signal ?? AbortSignal.timeout(this._timeout);
-    const { data } = await this._withServerRetry(
-      () => this._axiosClient.post("/v2/cognitive/generate-text", input, {
-        signal,
-        timeout: options.timeout ?? this._timeout
-      })
-    );
-    return data;
+    const req = { input };
+    this._events.emit("request", req);
+    try {
+      const { data } = await this._withServerRetry(
+        () => this._axiosClient.post("/v2/cognitive/generate-text", input, {
+          signal,
+          timeout: options.timeout ?? this._timeout
+        }),
+        options,
+        req
+      );
+      this._events.emit("response", req, data);
+      return data;
+    } catch (error) {
+      this._events.emit("error", req, error);
+      throw error;
+    }
   }
   async listModels() {
     const { data } = await this._withServerRetry(
@@ -1811,61 +1825,88 @@ var CognitiveBeta = class _CognitiveBeta {
   }
   async *generateTextStream(request, options = {}) {
     const signal = options.signal ?? AbortSignal.timeout(this._timeout);
-    if (isBrowser()) {
-      const res2 = await fetch(`${this._apiUrl}/v2/cognitive/generate-text-stream`, {
-        method: "POST",
-        headers: {
-          ...this._headers,
-          "Content-Type": "application/json"
-        },
-        credentials: this._withCredentials ? "include" : "omit",
-        body: JSON.stringify({ ...request, stream: true }),
-        signal
-      });
-      if (!res2.ok) {
-        const text = await res2.text().catch(() => "");
-        const err = new Error(`HTTP ${res2.status}: ${text || res2.statusText}`);
-        err.response = { status: res2.status, data: text };
-        throw err;
+    const req = { input: request };
+    const chunks = [];
+    let lastChunk;
+    this._events.emit("request", req);
+    try {
+      if (isBrowser()) {
+        const res2 = await fetch(`${this._apiUrl}/v2/cognitive/generate-text-stream`, {
+          method: "POST",
+          headers: {
+            ...this._headers,
+            "Content-Type": "application/json"
+          },
+          credentials: this._withCredentials ? "include" : "omit",
+          body: JSON.stringify({ ...request, stream: true }),
+          signal
+        });
+        if (!res2.ok) {
+          const text = await res2.text().catch(() => "");
+          const err = new Error(`HTTP ${res2.status}: ${text || res2.statusText}`);
+          err.response = { status: res2.status, data: text };
+          throw err;
+        }
+        const body = res2.body;
+        if (!body) {
+          throw new Error("No response body received for streaming request");
+        }
+        const reader = body.getReader();
+        const iterable = (async function* () {
+          for (; ; ) {
+            const { value, done } = await reader.read();
+            if (done) {
+              break;
+            }
+            if (value) {
+              yield value;
+            }
+          }
+        })();
+        for await (const obj of this._ndjson(iterable)) {
+          chunks.push(obj);
+          lastChunk = obj;
+          yield obj;
+        }
+        if (lastChunk?.metadata) {
+          this._events.emit("response", req, {
+            output: chunks.map((c) => c.output || "").join(""),
+            metadata: lastChunk.metadata
+          });
+        }
+        return;
       }
-      const body = res2.body;
-      if (!body) {
+      const res = await this._withServerRetry(
+        () => this._axiosClient.post(
+          "/v2/cognitive/generate-text-stream",
+          { ...request, stream: true },
+          {
+            responseType: "stream",
+            signal,
+            timeout: options.timeout ?? this._timeout
+          }
+        ),
+        options,
+        req
+      );
+      const nodeStream = res.data;
+      if (!nodeStream) {
         throw new Error("No response body received for streaming request");
       }
-      const reader = body.getReader();
-      const iterable = (async function* () {
-        for (; ; ) {
-          const { value, done } = await reader.read();
-          if (done) {
-            break;
-          }
-          if (value) {
-            yield value;
-          }
-        }
-      })();
-      for await (const obj of this._ndjson(iterable)) {
+      for await (const obj of this._ndjson(nodeStream)) {
+        chunks.push(obj);
+        lastChunk = obj;
         yield obj;
       }
-      return;
-    }
-    const res = await this._withServerRetry(
-      () => this._axiosClient.post(
-        "/v2/cognitive/generate-text-stream",
-        { ...request, stream: true },
-        {
-          responseType: "stream",
-          signal,
-          timeout: options.timeout ?? this._timeout
-        }
-      )
-    );
-    const nodeStream = res.data;
-    if (!nodeStream) {
-      throw new Error("No response body received for streaming request");
-    }
-    for await (const obj of this._ndjson(nodeStream)) {
-      yield obj;
+      if (lastChunk?.metadata) {
+        this._events.emit("response", req, {
+          output: chunks.map((c) => c.output || "").join(""),
+          metadata: lastChunk.metadata
+        });
+      }
+    } catch (error) {
+      this._events.emit("error", req, error);
+      throw error;
     }
   }
   async *_ndjson(stream) {
@@ -1907,14 +1948,30 @@ var CognitiveBeta = class _CognitiveBeta {
     }
     return false;
   }
-  async _withServerRetry(fn) {
-    return (0, import_exponential_backoff.backOff)(fn, {
-      numOfAttempts: 3,
-      startingDelay: 300,
-      timeMultiple: 2,
-      jitter: "full",
-      retry: (e) => this._isRetryableServerError(e)
-    });
+  async _withServerRetry(fn, options = {}, req) {
+    let attemptCount = 0;
+    return (0, import_exponential_backoff.backOff)(
+      async () => {
+        try {
+          const result = await fn();
+          attemptCount = 0;
+          return result;
+        } catch (error) {
+          if (attemptCount > 0 && req) {
+            this._events.emit("retry", req, error);
+          }
+          attemptCount++;
+          throw error;
+        }
+      },
+      {
+        numOfAttempts: 3,
+        startingDelay: 300,
+        timeMultiple: 2,
+        jitter: "full",
+        retry: (e) => !options.signal?.aborted && this._isRetryableServerError(e)
+      }
+    );
   }
 };
 var getCognitiveV2Model = (model) => {
@@ -2297,8 +2354,21 @@ var Cognitive = class _Cognitive {
       delete input.systemPrompt;
     }
     const betaClient = new CognitiveBeta(this._client.config);
-    const response = await betaClient.generateText(input);
-    return {
+    const props = { input };
+    betaClient.on("request", () => {
+      this._events.emit("request", props);
+    });
+    betaClient.on("error", (_req, error) => {
+      this._events.emit("error", props, error);
+    });
+    betaClient.on("retry", (_req, error) => {
+      this._events.emit("retry", props, error);
+    });
+    const response = await betaClient.generateText(input, {
+      signal: input.signal,
+      timeout: this._timeoutMs
+    });
+    const result = {
       output: {
         id: "beta-output",
         provider: response.metadata.provider,
@@ -2336,6 +2406,8 @@ var Cognitive = class _Cognitive {
         }
       }
     };
+    this._events.emit("response", props, result);
+    return result;
   }
   async _generateContent(input) {
     const start = Date.now();