@botpress/cognitive 0.1.50 → 0.2.0

package/dist/index.d.ts

@@ -19215,6 +19215,20 @@ type Model = {
     lifecycle: 'production' | 'preview' | 'deprecated' | 'discontinued';
 };
 
+type BetaEvents = {
+    request: (req: {
+        input: CognitiveRequest;
+    }) => void;
+    response: (req: {
+        input: CognitiveRequest;
+    }, res: CognitiveResponse) => void;
+    error: (req: {
+        input: CognitiveRequest;
+    }, error: any) => void;
+    retry: (req: {
+        input: CognitiveRequest;
+    }, error: any) => void;
+};
 type ClientProps = {
     apiUrl?: string;
     timeout?: number;
@@ -19236,8 +19250,10 @@ declare class CognitiveBeta {
     private readonly _withCredentials;
     private readonly _headers;
     private readonly _debug;
+    private _events;
     constructor(props: ClientProps);
     clone(): CognitiveBeta;
+    on<K extends keyof BetaEvents>(event: K, cb: BetaEvents[K]): Unsubscribe;
     generateText(input: CognitiveRequest, options?: RequestOptions): Promise<CognitiveResponse>;
     listModels(): Promise<Model[]>;
     generateTextStream(request: CognitiveRequest, options?: RequestOptions): AsyncGenerator<CognitiveStreamChunk, void, unknown>;
@@ -19247,4 +19263,4 @@ declare class CognitiveBeta {
 }
 declare const getCognitiveV2Model: (model: string) => Model | undefined;
 
-export { type BotpressClientLike, Cognitive, CognitiveBeta, type CognitiveRequest, type CognitiveResponse, type CognitiveStreamChunk, type Events, type GenerateContentInput, type GenerateContentOutput, type Model$1 as Model, type ModelPreferences, ModelProvider, type Models, RemoteModelProvider, getCognitiveV2Model };
+export { type BetaEvents, type BotpressClientLike, Cognitive, CognitiveBeta, type CognitiveRequest, type CognitiveResponse, type CognitiveStreamChunk, type Events, type GenerateContentInput, type GenerateContentOutput, type Model$1 as Model, type ModelPreferences, ModelProvider, type Models, RemoteModelProvider, getCognitiveV2Model };

package/dist/index.mjs

@@ -1747,6 +1747,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;
@@ -1777,15 +1778,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(
@@ -1795,61 +1809,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) {
@@ -1891,14 +1932,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) => {
@@ -2281,8 +2338,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,
@@ -2320,6 +2390,8 @@ var Cognitive = class _Cognitive {
         }
       }
     };
+    this._events.emit("response", props, result);
+    return result;
   }
   async _generateContent(input) {
     const start = Date.now();