@sentrial/sdk 0.3.0 → 0.3.2

package/dist/index.js

@@ -1108,17 +1108,6 @@ function wrapStreamText(originalFn, client, config) {
       const completionTokens = usage?.completionTokens || 0;
       const totalTokens = usage?.totalTokens || promptTokens + completionTokens;
       const cost = calculateCostForCall(provider, modelId, promptTokens, completionTokens);
-      await client.trackEvent({
-        sessionId: sid,
-        eventType: "llm_call",
-        eventData: {
-          model: modelId,
-          provider,
-          prompt_tokens: promptTokens,
-          completion_tokens: completionTokens,
-          total_tokens: totalTokens
-        }
-      });
       await client.completeSession({
         sessionId: sid,
         success: true,
@@ -1130,41 +1119,48 @@ function wrapStreamText(originalFn, client, config) {
         totalTokens
       });
     }
+    const originalTextStream = result.textStream;
+    let wrappedTextStream = null;
+    const proxied = new Proxy(result, {
+      get(target, prop, receiver) {
+        if (prop === "textStream") {
+          if (!wrappedTextStream) {
+            let fullText = "";
+            wrappedTextStream = (async function* () {
+              try {
+                for await (const chunk of originalTextStream) {
+                  fullText += chunk;
+                  yield chunk;
+                }
+                await trackCompletion(fullText);
+              } catch (error) {
+                await trackCompletion(
+                  fullText,
+                  error instanceof Error ? error : new Error(String(error))
+                );
+                throw error;
+              }
+            })();
+          }
+          return wrappedTextStream;
+        }
+        return Reflect.get(target, prop, receiver);
+      }
+    });
     const textProp = result.text;
     if (typeof textProp === "string") {
       trackCompletion(textProp).catch(() => {
       });
     } else if (textProp != null && typeof textProp.then === "function") {
-      const originalTextPromise = textProp;
-      result.text = originalTextPromise.then((text) => {
+      textProp.then((text) => {
         trackCompletion(text).catch(() => {
         });
-        return text;
       }).catch((err) => {
         trackCompletion("", err instanceof Error ? err : new Error(String(err))).catch(() => {
         });
-        throw err;
       });
-    } else {
-      const originalTextStream = result.textStream;
-      let fullText = "";
-      result.textStream = (async function* () {
-        try {
-          for await (const chunk of originalTextStream) {
-            fullText += chunk;
-            yield chunk;
-          }
-          await trackCompletion(fullText);
-        } catch (error) {
-          await trackCompletion(
-            "",
-            error instanceof Error ? error : new Error(String(error))
-          );
-          throw error;
-        }
-      })();
     }
-    return result;
+    return proxied;
   };
 }
 function wrapGenerateObject(originalFn, client, config) {
@@ -1251,50 +1247,64 @@ function wrapStreamObject(originalFn, client, config) {
       }
     })();
     const result = originalFn(params);
-    if (result.object) {
-      const originalObjectPromise = result.object;
-      result.object = originalObjectPromise.then(async (obj) => {
-        const durationMs = Date.now() - startTime;
-        const sid = await sessionPromise;
-        if (sid) {
-          let usage;
-          try {
-            usage = result.usage ? await result.usage : void 0;
-          } catch {
+    const originalObjectPromise = result.object;
+    if (originalObjectPromise && typeof originalObjectPromise.then === "function") {
+      let tracked = false;
+      let wrappedObjectPromise = null;
+      return new Proxy(result, {
+        get(target, prop, receiver) {
+          if (prop === "object") {
+            if (!wrappedObjectPromise) {
+              wrappedObjectPromise = originalObjectPromise.then(async (obj) => {
+                if (tracked) return obj;
+                tracked = true;
+                const durationMs = Date.now() - startTime;
+                const sid = await sessionPromise;
+                if (!sid) return obj;
+                let usage;
+                try {
+                  usage = result.usage ? await result.usage : void 0;
+                } catch {
+                }
+                const promptTokens = usage?.promptTokens || 0;
+                const completionTokens = usage?.completionTokens || 0;
+                const totalTokens = usage?.totalTokens || promptTokens + completionTokens;
+                const cost = calculateCostForCall(provider, modelId, promptTokens, completionTokens);
+                await client.completeSession({
+                  sessionId: sid,
+                  success: true,
+                  output: JSON.stringify(obj),
+                  durationMs,
+                  estimatedCost: cost,
+                  promptTokens,
+                  completionTokens,
+                  totalTokens
+                });
+                return obj;
+              }).catch(async (error) => {
+                if (tracked) throw error;
+                tracked = true;
+                const durationMs = Date.now() - startTime;
+                const sid = await sessionPromise;
+                if (!sid) throw error;
+                await client.trackError({
+                  sessionId: sid,
+                  errorType: error instanceof Error ? error.name : "Error",
+                  errorMessage: error instanceof Error ? error.message : "Unknown error"
+                });
+                await client.completeSession({
+                  sessionId: sid,
+                  success: false,
+                  failureReason: error instanceof Error ? error.message : "Unknown error",
+                  durationMs
+                });
+                throw error;
+              });
+            }
+            return wrappedObjectPromise;
           }
-          const promptTokens = usage?.promptTokens || 0;
-          const completionTokens = usage?.completionTokens || 0;
-          const totalTokens = usage?.totalTokens || promptTokens + completionTokens;
-          const cost = calculateCostForCall(provider, modelId, promptTokens, completionTokens);
-          await client.completeSession({
-            sessionId: sid,
-            success: true,
-            output: JSON.stringify(obj),
-            durationMs,
-            estimatedCost: cost,
-            promptTokens,
-            completionTokens,
-            totalTokens
-          });
-        }
-        return obj;
-      }).catch(async (error) => {
-        const durationMs = Date.now() - startTime;
-        const sid = await sessionPromise;
-        if (sid) {
-          await client.trackError({
-            sessionId: sid,
-            errorType: error instanceof Error ? error.name : "Error",
-            errorMessage: error instanceof Error ? error.message : "Unknown error"
-          });
-          await client.completeSession({
-            sessionId: sid,
-            success: false,
-            failureReason: error instanceof Error ? error.message : "Unknown error",
-            durationMs
-          });
+          return Reflect.get(target, prop, receiver);
         }
-        throw error;
       });
     }
     return result;