@sentrial/sdk 0.4.2 → 0.4.3

package/dist/index.cjs

@@ -437,8 +437,18 @@ function wrapOpenAI(client, options = {}) {
       const completionTokens = response.usage?.completion_tokens ?? 0;
       const totalTokens = response.usage?.total_tokens ?? 0;
       let outputContent = "";
-      if (response.choices?.[0]?.message?.content) {
-        outputContent = response.choices[0].message.content;
+      const toolCalls = [];
+      const msg = response.choices?.[0]?.message;
+      if (msg?.content) {
+        outputContent = msg.content;
+      }
+      if (msg?.tool_calls) {
+        for (const tc of msg.tool_calls) {
+          toolCalls.push({
+            name: tc.function?.name ?? "unknown",
+            arguments: tc.function?.arguments ?? "{}"
+          });
+        }
       }
       const cost = calculateOpenAICost({ model, inputTokens: promptTokens, outputTokens: completionTokens });
       trackLLMCall({
@@ -446,6 +456,7 @@ function wrapOpenAI(client, options = {}) {
         model,
         messages,
         output: outputContent,
+        toolCalls,
         promptTokens,
         completionTokens,
         totalTokens,
@@ -500,10 +511,16 @@ function wrapAnthropic(client, options = {}) {
       const completionTokens = response.usage?.output_tokens ?? 0;
       const totalTokens = promptTokens + completionTokens;
       let outputContent = "";
+      const toolCalls = [];
       if (response.content) {
         for (const block of response.content) {
           if (block.type === "text") {
             outputContent += block.text;
+          } else if (block.type === "tool_use") {
+            toolCalls.push({
+              name: block.name ?? "unknown",
+              arguments: JSON.stringify(block.input ?? {})
+            });
           }
         }
       }
@@ -514,6 +531,7 @@ function wrapAnthropic(client, options = {}) {
         model,
         messages: fullMessages,
         output: outputContent,
+        toolCalls,
         promptTokens,
         completionTokens,
         totalTokens,
@@ -627,6 +645,7 @@ function wrapLLM(client, provider) {
 function wrapOpenAIStream(stream, ctx) {
   let fullContent = "";
   let usage = null;
+  const toolCallMap = /* @__PURE__ */ new Map();
   let tracked = false;
   const originalIterator = stream[Symbol.asyncIterator]?.bind(stream);
   if (!originalIterator) return stream;
@@ -643,6 +662,7 @@ function wrapOpenAIStream(stream, ctx) {
       model: ctx.model,
       messages: ctx.messages,
       output: fullContent,
+      toolCalls: Array.from(toolCallMap.values()),
       promptTokens,
       completionTokens,
       totalTokens,
@@ -661,8 +681,17 @@ function wrapOpenAIStream(stream, ctx) {
               const result = await iter.next();
               if (!result.done) {
                 const chunk = result.value;
-                const delta = chunk.choices?.[0]?.delta?.content;
-                if (delta) fullContent += delta;
+                const delta = chunk.choices?.[0]?.delta;
+                if (delta?.content) fullContent += delta.content;
+                if (delta?.tool_calls) {
+                  for (const tc of delta.tool_calls) {
+                    const idx = tc.index ?? 0;
+                    const existing = toolCallMap.get(idx) ?? { name: "", arguments: "" };
+                    if (tc.function?.name) existing.name = tc.function.name;
+                    if (tc.function?.arguments) existing.arguments += tc.function.arguments;
+                    toolCallMap.set(idx, existing);
+                  }
+                }
                 if (chunk.usage) usage = chunk.usage;
               } else {
                 trackResult();
@@ -687,6 +716,8 @@ function wrapAnthropicStream(stream, ctx) {
   let fullContent = "";
   let inputTokens = 0;
   let outputTokens = 0;
+  const toolCallsById = /* @__PURE__ */ new Map();
+  let currentBlockIdx = -1;
   let tracked = false;
   const originalIterator = stream[Symbol.asyncIterator]?.bind(stream);
   if (!originalIterator) return stream;
@@ -702,6 +733,7 @@ function wrapAnthropicStream(stream, ctx) {
       model: ctx.model,
       messages: fullMessages,
       output: fullContent,
+      toolCalls: Array.from(toolCallsById.values()),
       promptTokens: inputTokens,
       completionTokens: outputTokens,
       totalTokens,
@@ -720,8 +752,26 @@ function wrapAnthropicStream(stream, ctx) {
               const result = await iter.next();
               if (!result.done) {
                 const event = result.value;
-                if (event.type === "content_block_delta" && event.delta?.text) {
-                  fullContent += event.delta.text;
+                if (event.type === "content_block_start") {
+                  currentBlockIdx = event.index ?? currentBlockIdx + 1;
+                  if (event.content_block?.type === "tool_use") {
+                    toolCallsById.set(currentBlockIdx, {
+                      name: event.content_block.name ?? "unknown",
+                      arguments: ""
+                    });
+                  }
+                }
+                if (event.type === "content_block_delta") {
+                  if (event.delta?.text) {
+                    fullContent += event.delta.text;
+                  }
+                  if (event.delta?.type === "input_json_delta" && event.delta?.partial_json) {
+                    const idx = event.index ?? currentBlockIdx;
+                    const existing = toolCallsById.get(idx);
+                    if (existing) {
+                      existing.arguments += event.delta.partial_json;
+                    }
+                  }
                 }
                 if (event.type === "message_start" && event.message?.usage) {
                   inputTokens = event.message.usage.input_tokens ?? 0;
@@ -755,6 +805,18 @@ function trackLLMCall(params) {
   if (!sessionId && !params.trackWithoutSession) {
     return;
   }
+  const toolOutput = {
+    content: params.output,
+    tokens: {
+      prompt: params.promptTokens,
+      completion: params.completionTokens,
+      total: params.totalTokens
+    },
+    cost_usd: params.cost
+  };
+  if (params.toolCalls && params.toolCalls.length > 0) {
+    toolOutput.tool_calls = params.toolCalls;
+  }
   if (sessionId) {
     client.trackToolCall({
       sessionId,
@@ -764,15 +826,7 @@ function trackLLMCall(params) {
         model: params.model,
         provider: params.provider
       },
-      toolOutput: {
-        content: params.output,
-        tokens: {
-          prompt: params.promptTokens,
-          completion: params.completionTokens,
-          total: params.totalTokens
-        },
-        cost_usd: params.cost
-      },
+      toolOutput,
       reasoning: `LLM call to ${params.provider} ${params.model}`,
       estimatedCost: params.cost,
       tokenCount: params.totalTokens,
@@ -801,15 +855,7 @@ function trackLLMCall(params) {
           model: params.model,
           provider: params.provider
         },
-        toolOutput: {
-          content: params.output,
-          tokens: {
-            prompt: params.promptTokens,
-            completion: params.completionTokens,
-            total: params.totalTokens
-          },
-          cost_usd: params.cost
-        },
+        toolOutput,
         estimatedCost: params.cost,
         tokenCount: params.totalTokens,
         metadata: {
@@ -1632,7 +1678,8 @@ function getClient2() {
 }
 function extractModelInfo(model) {
   const modelId = model.modelId || model.id || "unknown";
-  const provider = model.provider || guessProvider(modelId);
+  const rawProvider = model.provider || "";
+  const provider = rawProvider.split(".")[0] || guessProvider(modelId);
   return { modelId, provider };
 }
 function guessProvider(modelId) {
@@ -1677,6 +1724,15 @@ function extractInput(params) {
   }
   return "";
 }
+function normalizeUsage(usage) {
+  if (!usage) return void 0;
+  const u = usage;
+  const promptTokens = (u.inputTokens ?? u.promptTokens ?? 0) || 0;
+  const completionTokens = (u.outputTokens ?? u.completionTokens ?? 0) || 0;
+  const totalTokens = (u.totalTokens ?? promptTokens + completionTokens) || 0;
+  if (promptTokens === 0 && completionTokens === 0 && totalTokens === 0) return void 0;
+  return { promptTokens, completionTokens, totalTokens };
+}
 function wrapTools(tools, sessionId, client) {
   if (!tools) return void 0;
   const wrappedTools = {};
@@ -1729,34 +1785,37 @@ function wrapToolsAsync(tools, sessionPromise, client) {
         ...tool,
         execute: async (...args) => {
           const startTime = Date.now();
-          const sid = await sessionPromise;
           try {
             const result = await originalExecute(...args);
             const durationMs = Date.now() - startTime;
-            if (sid) {
-              client.trackToolCall({
-                sessionId: sid,
-                toolName,
-                toolInput: args[0],
-                toolOutput: result,
-                reasoning: `Tool executed in ${durationMs}ms`
-              }).catch(() => {
-              });
-            }
+            sessionPromise.then((sid) => {
+              if (sid) {
+                client.trackToolCall({
+                  sessionId: sid,
+                  toolName,
+                  toolInput: args[0],
+                  toolOutput: result,
+                  reasoning: `Tool executed in ${durationMs}ms`
+                }).catch(() => {
+                });
+              }
+            });
             return result;
           } catch (error) {
             const durationMs = Date.now() - startTime;
-            if (sid) {
-              client.trackToolCall({
-                sessionId: sid,
-                toolName,
-                toolInput: args[0],
-                toolOutput: {},
-                toolError: { message: error instanceof Error ? error.message : "Unknown error" },
-                reasoning: `Tool failed after ${durationMs}ms`
-              }).catch(() => {
-              });
-            }
+            sessionPromise.then((sid) => {
+              if (sid) {
+                client.trackToolCall({
+                  sessionId: sid,
+                  toolName,
+                  toolInput: args[0],
+                  toolOutput: {},
+                  toolError: { message: error instanceof Error ? error.message : "Unknown error" },
+                  reasoning: `Tool failed after ${durationMs}ms`
+                }).catch(() => {
+                });
+              }
+            });
             throw error;
           }
         }
@@ -1796,44 +1855,50 @@ function wrapGenerateText(originalFn, client, config) {
       const result = await originalFn(wrappedParams);
       const durationMs = Date.now() - startTime;
       const resolvedModelId = result.response?.modelId || modelId;
-      const promptTokens = result.usage?.promptTokens ?? 0;
-      const completionTokens = result.usage?.completionTokens ?? 0;
-      const totalTokens = result.usage?.totalTokens ?? promptTokens + completionTokens;
+      const usage = normalizeUsage(result.usage);
+      const promptTokens = usage?.promptTokens ?? 0;
+      const completionTokens = usage?.completionTokens ?? 0;
+      const totalTokens = usage?.totalTokens ?? 0;
       const cost = calculateCostForCall(provider, resolvedModelId, promptTokens, completionTokens);
       const steps = result.steps;
       if (steps && steps.length >= 1) {
-        const stepPromises = steps.map(
-          (step, i) => client.trackEvent({
+        const stepPromises = steps.map((step) => {
+          const su = normalizeUsage(step.usage);
+          return client.trackToolCall({
             sessionId,
-            eventType: "llm_call",
-            eventData: {
-              model: resolvedModelId,
-              provider,
-              step: i + 1,
-              total_steps: steps.length,
-              prompt_tokens: step.usage?.promptTokens ?? 0,
-              completion_tokens: step.usage?.completionTokens ?? 0,
-              total_tokens: step.usage?.totalTokens ?? 0,
-              finish_reason: step.finishReason,
+            toolName: `llm:${provider}:${resolvedModelId}`,
+            toolInput: { finishReason: step.finishReason },
+            toolOutput: {
+              text: step.text?.slice(0, 500),
+              tokens: {
+                prompt: su?.promptTokens ?? 0,
+                completion: su?.completionTokens ?? 0
+              }
+            },
+            estimatedCost: calculateCostForCall(provider, resolvedModelId, su?.promptTokens ?? 0, su?.completionTokens ?? 0),
+            tokenCount: su?.totalTokens,
+            metadata: {
               tool_calls: step.toolCalls?.map((tc) => tc.toolName)
             }
           }).catch(() => {
-          })
-        );
+          });
+        });
         await Promise.all(stepPromises);
       } else {
-        await client.trackEvent({
+        await client.trackToolCall({
           sessionId,
-          eventType: "llm_call",
-          eventData: {
-            model: resolvedModelId,
-            provider,
-            prompt_tokens: promptTokens,
-            completion_tokens: completionTokens,
-            total_tokens: totalTokens,
-            finish_reason: result.finishReason,
+          toolName: `llm:${provider}:${resolvedModelId}`,
+          toolInput: { finishReason: result.finishReason },
+          toolOutput: {
+            text: result.text?.slice(0, 500),
+            tokens: { prompt: promptTokens, completion: completionTokens }
+          },
+          estimatedCost: cost,
+          tokenCount: totalTokens,
+          metadata: {
             tool_calls: result.toolCalls?.map((tc) => tc.toolName)
           }
+        }).catch(() => {
         });
       }
       await client.completeSession({
@@ -1870,7 +1935,11 @@ function wrapStreamText(originalFn, client, config) {
     const { modelId, provider } = extractModelInfo(params.model);
     const input = extractInput(params);
     let sessionId = null;
-    const sessionPromise = (async () => {
+    let resolveSessionReady;
+    const sessionReady = new Promise((resolve) => {
+      resolveSessionReady = resolve;
+    });
+    (async () => {
       try {
         const id = await client.createSession({
           name: `streamText: ${input.slice(0, 50)}${input.length > 50 ? "..." : ""}`,
@@ -1888,143 +1957,120 @@ function wrapStreamText(originalFn, client, config) {
           client.setInput(id, input).catch(() => {
           });
         }
-        return id;
       } catch {
-        return null;
+        sessionId = null;
       }
+      resolveSessionReady();
     })();
+    const userOnStepFinish = params.onStepFinish;
+    const userOnFinish = params.onFinish;
+    const userOnError = params.onError;
     const wrappedParams = {
       ...params,
-      tools: params.tools ? wrapToolsAsync(params.tools, sessionPromise, client) : void 0
-    };
-    const result = originalFn(wrappedParams);
-    const originalTextStream = result.textStream;
-    let fullText = "";
-    let tracked = false;
-    async function trackCompletion(text, error) {
-      if (tracked) return;
-      tracked = true;
-      const durationMs = Date.now() - startTime;
-      const sid = sessionId || await sessionPromise;
-      if (!sid) return;
-      if (error) {
-        await client.trackError({
-          sessionId: sid,
-          errorType: error.name || "Error",
-          errorMessage: error.message || "Unknown error"
-        }).catch(() => {
-        });
-        await client.completeSession({
-          sessionId: sid,
-          success: false,
-          failureReason: error.message || "Unknown error",
-          durationMs
-        }).catch(() => {
-        });
-        return;
-      }
-      let resolvedModelId = modelId;
-      try {
-        const resp = result.response ? await result.response : void 0;
-        if (resp?.modelId) resolvedModelId = resp.modelId;
-      } catch {
-      }
-      let usage;
-      try {
-        usage = result.usage ? await result.usage : void 0;
-      } catch {
-      }
-      let steps;
-      try {
-        steps = result.steps ? await result.steps : void 0;
-      } catch {
-      }
-      if (steps && steps.length >= 1) {
-        let totalPrompt = 0, totalCompletion = 0;
-        const stepPromises = steps.map((step, i) => {
-          const sp = step.usage?.promptTokens ?? 0;
-          const sc = step.usage?.completionTokens ?? 0;
-          totalPrompt += sp;
-          totalCompletion += sc;
-          return client.trackEvent({
-            sessionId: sid,
-            eventType: "llm_call",
-            eventData: {
-              model: resolvedModelId,
-              provider,
-              step: i + 1,
-              total_steps: steps.length,
-              prompt_tokens: sp,
-              completion_tokens: sc,
-              total_tokens: step.usage?.totalTokens ?? 0,
-              finish_reason: step.finishReason,
+      tools: params.tools ? wrapToolsAsync(params.tools, sessionReady.then(() => sessionId), client) : void 0,
+      onStepFinish: async (step) => {
+        await sessionReady;
+        if (sessionId) {
+          const su = normalizeUsage(step.usage);
+          const resolvedStepModel = step.response?.modelId ?? modelId;
+          client.trackToolCall({
+            sessionId,
+            toolName: `llm:${provider}:${resolvedStepModel}`,
+            toolInput: { finishReason: step.finishReason },
+            toolOutput: {
+              text: step.text?.slice(0, 500),
+              tokens: {
+                prompt: su?.promptTokens ?? 0,
+                completion: su?.completionTokens ?? 0
+              }
+            },
+            estimatedCost: calculateCostForCall(provider, resolvedStepModel, su?.promptTokens ?? 0, su?.completionTokens ?? 0),
+            tokenCount: su?.totalTokens,
+            metadata: {
               tool_calls: step.toolCalls?.map((tc) => tc.toolName)
             }
           }).catch(() => {
           });
-        });
-        await Promise.all(stepPromises);
-        const promptTokens = usage?.promptTokens ?? totalPrompt;
-        const completionTokens = usage?.completionTokens ?? totalCompletion;
-        const totalTokens = usage?.totalTokens ?? promptTokens + completionTokens;
-        const cost = calculateCostForCall(provider, resolvedModelId, promptTokens, completionTokens);
-        await client.completeSession({
-          sessionId: sid,
-          success: true,
-          output: text,
-          durationMs,
-          estimatedCost: cost,
-          promptTokens,
-          completionTokens,
-          totalTokens
-        }).catch(() => {
-        });
-      } else {
-        const promptTokens = usage?.promptTokens ?? 0;
-        const completionTokens = usage?.completionTokens ?? 0;
-        const totalTokens = usage?.totalTokens ?? promptTokens + completionTokens;
-        const cost = calculateCostForCall(provider, resolvedModelId, promptTokens, completionTokens);
-        await client.trackEvent({
-          sessionId: sid,
-          eventType: "llm_call",
-          eventData: {
-            model: resolvedModelId,
-            provider,
-            prompt_tokens: promptTokens,
-            completion_tokens: completionTokens,
-            total_tokens: totalTokens
+        }
+        if (userOnStepFinish) {
+          try {
+            userOnStepFinish(step);
+          } catch {
+          }
+        }
+      },
+      onFinish: async (event) => {
+        await sessionReady;
+        if (sessionId) {
+          const durationMs = Date.now() - startTime;
+          const usage = normalizeUsage(event.totalUsage ?? event.usage);
+          const resolvedModelId = event.response?.modelId ?? modelId;
+          const text = event.text ?? "";
+          const promptTokens = usage?.promptTokens ?? 0;
+          const completionTokens = usage?.completionTokens ?? 0;
+          const totalTokens = usage?.totalTokens ?? promptTokens + completionTokens;
+          const cost = calculateCostForCall(provider, resolvedModelId, promptTokens, completionTokens);
+          await client.completeSession({
+            sessionId,
+            success: true,
+            output: text,
+            durationMs,
+            estimatedCost: cost,
+            promptTokens,
+            completionTokens,
+            totalTokens
+          }).catch(() => {
+          });
+        }
+        if (userOnFinish) {
+          try {
+            userOnFinish(event);
+          } catch {
+          }
+        }
+      },
+      onError: async (event) => {
+        await sessionReady;
+        if (sessionId) {
+          const durationMs = Date.now() - startTime;
+          const msg = event.error?.message ?? "Unknown error";
+          await client.trackError({
+            sessionId,
+            errorType: event.error?.name ?? "Error",
+            errorMessage: msg
+          }).catch(() => {
+          });
+          await client.completeSession({
+            sessionId,
+            success: false,
+            failureReason: msg,
+            durationMs
+          }).catch(() => {
+          });
+        }
+        if (userOnError) {
+          try {
+            userOnError(event);
+          } catch {
           }
-        }).catch(() => {
-        });
-        await client.completeSession({
-          sessionId: sid,
-          success: true,
-          output: text,
-          durationMs,
-          estimatedCost: cost,
-          promptTokens,
-          completionTokens,
-          totalTokens
-        }).catch(() => {
-        });
-      }
-    }
-    result.textStream = (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 result;
+    };
+    try {
+      return originalFn(wrappedParams);
+    } catch (error) {
+      sessionReady.then(() => {
+        if (sessionId) {
+          const durationMs = Date.now() - startTime;
+          const msg = error instanceof Error ? error.message : String(error);
+          client.trackError({ sessionId, errorType: error instanceof Error ? error.name : "Error", errorMessage: msg }).catch(() => {
+          });
+          client.completeSession({ sessionId, success: false, failureReason: msg, durationMs }).catch(() => {
+          });
+        }
+      });
+      throw error;
+    }
   };
 }
 function wrapGenerateObject(originalFn, client, config) {
@@ -2051,20 +2097,21 @@ function wrapGenerateObject(originalFn, client, config) {
       const result = await originalFn(params);
       const durationMs = Date.now() - startTime;
       const resolvedModelId = result.response?.modelId || modelId;
-      const promptTokens = result.usage?.promptTokens ?? 0;
-      const completionTokens = result.usage?.completionTokens ?? 0;
-      const totalTokens = result.usage?.totalTokens ?? promptTokens + completionTokens;
+      const usage = normalizeUsage(result.usage);
+      const promptTokens = usage?.promptTokens ?? 0;
+      const completionTokens = usage?.completionTokens ?? 0;
+      const totalTokens = usage?.totalTokens ?? 0;
       const cost = calculateCostForCall(provider, resolvedModelId, promptTokens, completionTokens);
-      await client.trackEvent({
+      await client.trackToolCall({
         sessionId,
-        eventType: "llm_call",
-        eventData: {
-          model: resolvedModelId,
-          provider,
-          prompt_tokens: promptTokens,
-          completion_tokens: completionTokens,
-          total_tokens: totalTokens
-        }
+        toolName: `llm:${provider}:${resolvedModelId}`,
+        toolInput: { function: "generateObject" },
+        toolOutput: {
+          object: result.object,
+          tokens: { prompt: promptTokens, completion: completionTokens }
+        },
+        estimatedCost: cost,
+        tokenCount: totalTokens
       }).catch(() => {
       });
       await client.completeSession({
@@ -2100,7 +2147,12 @@ function wrapStreamObject(originalFn, client, config) {
     const startTime = Date.now();
     const { modelId, provider } = extractModelInfo(params.model);
     const input = extractInput(params);
-    const sessionPromise = (async () => {
+    let sessionId = null;
+    let resolveSessionReady;
+    const sessionReady = new Promise((resolve) => {
+      resolveSessionReady = resolve;
+    });
+    (async () => {
       try {
         const id = await client.createSession({
           name: `streamObject: ${input.slice(0, 50)}${input.length > 50 ? "..." : ""}`,
@@ -2113,86 +2165,113 @@ function wrapStreamObject(originalFn, client, config) {
             function: "streamObject"
           }
         });
+        sessionId = id;
         if (id) {
           client.setInput(id, input).catch(() => {
           });
         }
-        return id;
       } catch {
-        return null;
+        sessionId = null;
       }
+      resolveSessionReady();
     })();
-    const result = originalFn(params);
-    async function completeStreamObject(obj, error) {
-      const durationMs = Date.now() - startTime;
-      const sid = await sessionPromise;
-      if (!sid) return;
-      if (error) {
-        await client.trackError({
-          sessionId: sid,
-          errorType: error.name || "Error",
-          errorMessage: error.message || "Unknown error"
-        }).catch(() => {
-        });
-        await client.completeSession({
-          sessionId: sid,
-          success: false,
-          failureReason: error.message || "Unknown error",
-          durationMs
-        }).catch(() => {
-        });
-        return;
-      }
-      let usage;
-      try {
-        usage = result.usage ? await result.usage : void 0;
-      } catch {
+    const userOnFinish = params.onFinish;
+    const userOnError = params.onError;
+    const wrappedParams = {
+      ...params,
+      onFinish: async (event) => {
+        await sessionReady;
+        if (sessionId) {
+          const durationMs = Date.now() - startTime;
+          const usage = normalizeUsage(event.usage);
+          const resolvedModelId = event.response?.modelId ?? modelId;
+          const promptTokens = usage?.promptTokens ?? 0;
+          const completionTokens = usage?.completionTokens ?? 0;
+          const totalTokens = usage?.totalTokens ?? 0;
+          const cost = calculateCostForCall(provider, resolvedModelId, promptTokens, completionTokens);
+          if (event.error) {
+            const errMsg = event.error instanceof Error ? event.error.message : String(event.error);
+            await client.trackError({
+              sessionId,
+              errorType: "SchemaValidationError",
+              errorMessage: errMsg
+            }).catch(() => {
+            });
+          }
+          await client.trackToolCall({
+            sessionId,
+            toolName: `llm:${provider}:${resolvedModelId}`,
+            toolInput: { function: "streamObject" },
+            toolOutput: {
+              object: event.object,
+              tokens: { prompt: promptTokens, completion: completionTokens }
+            },
+            estimatedCost: cost,
+            tokenCount: totalTokens
+          }).catch(() => {
+          });
+          await client.completeSession({
+            sessionId,
+            success: !event.error,
+            output: event.object != null ? JSON.stringify(event.object) : void 0,
+            failureReason: event.error ? String(event.error) : void 0,
+            durationMs,
+            estimatedCost: cost,
+            promptTokens,
+            completionTokens,
+            totalTokens
+          }).catch(() => {
+          });
+        }
+        if (userOnFinish) {
+          try {
+            userOnFinish(event);
+          } catch {
+          }
+        }
+      },
+      onError: async (event) => {
+        await sessionReady;
+        if (sessionId) {
+          const durationMs = Date.now() - startTime;
+          const msg = event.error?.message ?? "Unknown error";
+          await client.trackError({
+            sessionId,
+            errorType: event.error?.name ?? "Error",
+            errorMessage: msg
+          }).catch(() => {
+          });
+          await client.completeSession({
+            sessionId,
+            success: false,
+            failureReason: msg,
+            durationMs
+          }).catch(() => {
+          });
+        }
+        if (userOnError) {
+          try {
+            userOnError(event);
+          } 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.trackEvent({
-        sessionId: sid,
-        eventType: "llm_call",
-        eventData: {
-          model: modelId,
-          provider,
-          prompt_tokens: promptTokens,
-          completion_tokens: completionTokens,
-          total_tokens: totalTokens
+    };
+    try {
+      return originalFn(wrappedParams);
+    } catch (error) {
+      sessionReady.then(() => {
+        if (sessionId) {
+          const durationMs = Date.now() - startTime;
+          const msg = error instanceof Error ? error.message : String(error);
+          client.trackError({ sessionId, errorType: error instanceof Error ? error.name : "Error", errorMessage: msg }).catch(() => {
+          });
+          client.completeSession({ sessionId, success: false, failureReason: msg, durationMs }).catch(() => {
+          });
         }
-      }).catch(() => {
-      });
-      await client.completeSession({
-        sessionId: sid,
-        success: true,
-        output: JSON.stringify(obj),
-        durationMs,
-        estimatedCost: cost,
-        promptTokens,
-        completionTokens,
-        totalTokens
-      }).catch(() => {
-      });
-    }
-    if (result.object) {
-      const originalObjectPromise = result.object;
-      result.object = originalObjectPromise.then(async (obj) => {
-        await completeStreamObject(obj);
-        return obj;
-      }).catch(async (error) => {
-        await completeStreamObject(void 0, error instanceof Error ? error : new Error(String(error)));
-        throw error;
-      });
-    } else if (result.usage) {
-      result.usage.then(async () => {
-        await completeStreamObject(void 0);
-      }).catch(async (error) => {
-        await completeStreamObject(void 0, error instanceof Error ? error : new Error(String(error)));
       });
+      throw error;
     }
-    return result;
   };
 }
 function wrapAISDK(ai, options) {