@sentrial/sdk 0.2.0 → 0.3.1

package/dist/index.cjs

@@ -47,7 +47,12 @@ __export(index_exports, {
   getSessionContext: () => getSessionContext,
   getSystemPrompt: () => getSystemPrompt,
   getVariantName: () => getVariantName,
+  hashValue: () => hashValue,
   isExperimentMode: () => isExperimentMode,
+  redactPayload: () => redactPayload,
+  redactString: () => redactString,
+  redactValue: () => redactValue,
+  replaceMatch: () => replaceMatch,
   sentrial: () => sentrial,
   setClient: () => setClient,
   setDefaultClient: () => setDefaultClient,
@@ -132,26 +137,126 @@ var ValidationError = class extends SentrialError {
   }
 };
 
+// src/redact.ts
+var import_crypto = require("crypto");
+var DEFAULT_FIELDS = [
+  "userInput",
+  "assistantOutput",
+  "toolInput",
+  "toolOutput"
+];
+var DEFAULT_BUILTIN = {
+  emails: true,
+  phones: true,
+  ssns: true,
+  creditCards: true,
+  ipAddresses: true
+};
+var EMAIL_PATTERN = /[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g;
+var PHONE_PATTERN = /(?:\+?1[-.\s]?)?\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}\b/g;
+var SSN_PATTERN = /\b\d{3}-\d{2}-\d{4}\b/g;
+var CREDIT_CARD_PATTERN = /\b(?:\d[-\s]?){13,19}\b/g;
+var IP_ADDRESS_PATTERN = /\b(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\b/g;
+var BUILTIN_PATTERNS = {
+  emails: { pattern: EMAIL_PATTERN, label: "EMAIL" },
+  phones: { pattern: PHONE_PATTERN, label: "PHONE" },
+  ssns: { pattern: SSN_PATTERN, label: "SSN" },
+  creditCards: { pattern: CREDIT_CARD_PATTERN, label: "CREDIT_CARD" },
+  ipAddresses: { pattern: IP_ADDRESS_PATTERN, label: "IP_ADDRESS" }
+};
+function hashValue(value) {
+  return (0, import_crypto.createHash)("sha256").update(value).digest("hex").slice(0, 6);
+}
+function replaceMatch(match, label, mode) {
+  switch (mode) {
+    case "label":
+      return `[${label}]`;
+    case "hash":
+      return `[PII:${hashValue(match)}]`;
+    case "remove":
+      return "";
+  }
+}
+function redactString(value, mode, builtinPatterns, customPatterns) {
+  let result = value;
+  for (const [key, config] of Object.entries(BUILTIN_PATTERNS)) {
+    if (builtinPatterns[key]) {
+      const regex = new RegExp(config.pattern.source, config.pattern.flags);
+      result = result.replace(regex, (match) => replaceMatch(match, config.label, mode));
+    }
+  }
+  for (const custom of customPatterns) {
+    const regex = new RegExp(custom.pattern.source, custom.pattern.flags);
+    result = result.replace(regex, (match) => replaceMatch(match, custom.label, mode));
+  }
+  return result;
+}
+function redactValue(value, mode, builtinPatterns, customPatterns) {
+  if (typeof value === "string") {
+    return redactString(value, mode, builtinPatterns, customPatterns);
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => redactValue(item, mode, builtinPatterns, customPatterns));
+  }
+  if (value !== null && typeof value === "object") {
+    const result = {};
+    for (const [key, val] of Object.entries(value)) {
+      result[key] = redactValue(val, mode, builtinPatterns, customPatterns);
+    }
+    return result;
+  }
+  return value;
+}
+function redactPayload(payload, config) {
+  if (!config.enabled) {
+    return payload;
+  }
+  const mode = config.mode ?? "label";
+  const fields = config.fields ?? DEFAULT_FIELDS;
+  const builtinPatterns = {
+    ...DEFAULT_BUILTIN,
+    ...config.builtinPatterns
+  };
+  const customPatterns = config.customPatterns ?? [];
+  const result = { ...payload };
+  for (const field of fields) {
+    if (field in result && result[field] !== void 0 && result[field] !== null) {
+      result[field] = redactValue(result[field], mode, builtinPatterns, customPatterns);
+    }
+  }
+  return result;
+}
+
 // src/cost.ts
 var OPENAI_PRICING = {
   "gpt-5.2": { input: 5, output: 15 },
   "gpt-5": { input: 4, output: 12 },
+  "gpt-4.1": { input: 2, output: 8 },
+  "gpt-4.1-mini": { input: 0.4, output: 1.6 },
+  "gpt-4.1-nano": { input: 0.1, output: 0.4 },
   "gpt-4o": { input: 2.5, output: 10 },
   "gpt-4o-mini": { input: 0.15, output: 0.6 },
   "gpt-4-turbo": { input: 10, output: 30 },
   "gpt-4": { input: 30, output: 60 },
   "gpt-3.5-turbo": { input: 0.5, output: 1.5 },
+  "o4-mini": { input: 1.1, output: 4.4 },
   "o3": { input: 10, output: 40 },
-  "o3-mini": { input: 3, output: 12 },
+  "o3-mini": { input: 1.1, output: 4.4 },
+  "o3-pro": { input: 20, output: 80 },
+  "o1": { input: 15, output: 60 },
   "o1-preview": { input: 15, output: 60 },
   "o1-mini": { input: 3, output: 12 }
 };
 var ANTHROPIC_PRICING = {
+  "claude-opus-4": { input: 15, output: 75 },
+  "claude-sonnet-4": { input: 3, output: 15 },
   "claude-4.5-opus": { input: 20, output: 100 },
   "claude-4.5-sonnet": { input: 4, output: 20 },
   "claude-4-opus": { input: 18, output: 90 },
   "claude-4-sonnet": { input: 3.5, output: 17.5 },
+  "claude-3-7-sonnet": { input: 3, output: 15 },
   "claude-3-5-sonnet": { input: 3, output: 15 },
+  "claude-3-5-haiku": { input: 0.8, output: 4 },
   "claude-3-opus": { input: 15, output: 75 },
   "claude-3-sonnet": { input: 3, output: 15 },
   "claude-3-haiku": { input: 0.25, output: 1.25 }
@@ -222,11 +327,75 @@ var SentrialClient = class {
   apiUrl;
   apiKey;
   failSilently;
+  piiConfig;
+  piiConfigNeedsHydration = false;
+  piiHydrationPromise;
   currentState = {};
   constructor(config = {}) {
     this.apiUrl = (config.apiUrl ?? (typeof process !== "undefined" ? process.env?.SENTRIAL_API_URL : void 0) ?? DEFAULT_API_URL).replace(/\/$/, "");
     this.apiKey = config.apiKey ?? (typeof process !== "undefined" ? process.env?.SENTRIAL_API_KEY : void 0);
     this.failSilently = config.failSilently ?? true;
+    if (config.pii === true) {
+      this.piiConfig = { enabled: true };
+      this.piiConfigNeedsHydration = true;
+    } else if (config.pii && typeof config.pii === "object") {
+      this.piiConfig = config.pii;
+      this.piiConfigNeedsHydration = false;
+    }
+  }
+  /**
+   * Fetch the organization's PII config from the server.
+   *
+   * Called lazily on the first request when `pii: true` was passed to the constructor.
+   * Uses a single shared promise so concurrent requests don't trigger duplicate fetches.
+   */
+  async hydratePiiConfig() {
+    if (!this.piiConfigNeedsHydration) return;
+    if (this.piiHydrationPromise) {
+      await this.piiHydrationPromise;
+      return;
+    }
+    this.piiHydrationPromise = (async () => {
+      try {
+        const headers = {};
+        if (this.apiKey) {
+          headers["Authorization"] = `Bearer ${this.apiKey}`;
+        }
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+        let response;
+        try {
+          response = await fetch(`${this.apiUrl}/api/sdk/pii-config`, {
+            method: "GET",
+            headers,
+            signal: controller.signal
+          });
+        } finally {
+          clearTimeout(timeoutId);
+        }
+        if (response.ok) {
+          const data = await response.json();
+          if (data.config) {
+            this.piiConfig = {
+              enabled: data.config.enabled,
+              mode: data.config.mode,
+              fields: data.config.fields,
+              builtinPatterns: data.config.builtinPatterns,
+              customPatterns: (data.config.customPatterns || []).map(
+                (cp) => ({
+                  pattern: new RegExp(cp.pattern, "g"),
+                  label: cp.label
+                })
+              ),
+              enhancedDetection: data.config.enhancedDetection
+            };
+          }
+        }
+      } catch {
+      }
+      this.piiConfigNeedsHydration = false;
+    })();
+    await this.piiHydrationPromise;
   }
   /**
    * Make an HTTP request with retry logic and exponential backoff.
@@ -235,6 +404,9 @@ var SentrialClient = class {
    * Up to MAX_RETRIES attempts with exponential backoff.
    */
   async safeRequest(method, url, body) {
+    if (this.piiConfigNeedsHydration) {
+      await this.hydratePiiConfig();
+    }
     let lastError;
     let backoff = INITIAL_BACKOFF_MS;
     for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
@@ -245,6 +417,7 @@ var SentrialClient = class {
         if (this.apiKey) {
           headers["Authorization"] = `Bearer ${this.apiKey}`;
         }
+        const finalBody = this.piiConfig && body && typeof body === "object" ? redactPayload(body, this.piiConfig) : body;
         const controller = new AbortController();
         const timeoutId = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
         let response;
@@ -252,7 +425,7 @@ var SentrialClient = class {
           response = await fetch(url, {
             method,
             headers,
-            body: body ? JSON.stringify(body) : void 0,
+            body: finalBody ? JSON.stringify(finalBody) : void 0,
             signal: controller.signal
           });
         } finally {
@@ -324,6 +497,9 @@ var SentrialClient = class {
     if (params.parentSessionId) {
       payload.parentSessionId = params.parentSessionId;
     }
+    if (params.convoId) {
+      payload.convoId = params.convoId;
+    }
     const response = await this.safeRequest(
       "POST",
       `${this.apiUrl}/api/sdk/sessions`,
@@ -530,6 +706,7 @@ var SentrialClient = class {
       name: `${params.event}:${eventId.slice(0, 8)}`,
       agentName: params.event,
       userId: params.userId,
+      convoId: params.convoId,
       metadata: fullMetadata
     });
     if (params.input) {
@@ -694,7 +871,8 @@ function configureVercel(config) {
   });
   _globalConfig = {
     defaultAgent: config.defaultAgent,
-    userId: config.userId
+    userId: config.userId,
+    convoId: config.convoId
   };
 }
 function getClient2() {
@@ -709,11 +887,15 @@ function extractModelInfo(model) {
   return { modelId, provider };
 }
 function guessProvider(modelId) {
-  if (modelId.includes("gpt") || modelId.includes("o1") || modelId.includes("o3")) return "openai";
-  if (modelId.includes("claude")) return "anthropic";
-  if (modelId.includes("gemini")) return "google";
-  if (modelId.includes("mistral")) return "mistral";
-  if (modelId.includes("llama")) return "meta";
+  const id = modelId.toLowerCase();
+  if (id.includes("gpt") || id.includes("o1") || id.includes("o3") || id.includes("o4") || id.startsWith("chatgpt")) return "openai";
+  if (id.includes("claude")) return "anthropic";
+  if (id.includes("gemini")) return "google";
+  if (id.includes("mistral") || id.includes("mixtral") || id.includes("codestral") || id.includes("pixtral")) return "mistral";
+  if (id.includes("llama")) return "meta";
+  if (id.includes("deepseek")) return "deepseek";
+  if (id.includes("command")) return "cohere";
+  if (id.includes("qwen")) return "alibaba";
   return "unknown";
 }
 function calculateCostForCall(provider, modelId, promptTokens, completionTokens) {
@@ -725,6 +907,12 @@ function calculateCostForCall(provider, modelId, promptTokens, completionTokens)
       return calculateAnthropicCost(params);
     case "google":
       return calculateGoogleCost(params);
+    case "deepseek":
+      return promptTokens / 1e6 * 0.27 + completionTokens / 1e6 * 1.1;
+    case "cohere":
+      return promptTokens / 1e6 * 0.5 + completionTokens / 1e6 * 1.5;
+    case "mistral":
+      return promptTokens / 1e6 * 2 + completionTokens / 1e6 * 6;
     default:
       return promptTokens * 3e-6 + completionTokens * 6e-6;
   }
@@ -733,7 +921,10 @@ function extractInput(params) {
   if (params.prompt) return params.prompt;
   if (params.messages && params.messages.length > 0) {
     const lastUserMessage = [...params.messages].reverse().find((m) => m.role === "user");
-    return lastUserMessage?.content || JSON.stringify(params.messages);
+    if (lastUserMessage) {
+      return typeof lastUserMessage.content === "string" ? lastUserMessage.content : JSON.stringify(lastUserMessage.content);
+    }
+    return JSON.stringify(params.messages);
   }
   return "";
 }
@@ -750,23 +941,25 @@ function wrapTools(tools, sessionId, client) {
           try {
             const result = await originalExecute(...args);
             const durationMs = Date.now() - startTime;
-            await client.trackToolCall({
+            client.trackToolCall({
               sessionId,
               toolName,
               toolInput: args[0],
               toolOutput: result,
               reasoning: `Tool executed in ${durationMs}ms`
+            }).catch(() => {
             });
             return result;
           } catch (error) {
             const durationMs = Date.now() - startTime;
-            await client.trackToolCall({
+            client.trackToolCall({
               sessionId,
               toolName,
               toolInput: args[0],
               toolOutput: {},
               toolError: { message: error instanceof Error ? error.message : "Unknown error" },
               reasoning: `Tool failed after ${durationMs}ms`
+            }).catch(() => {
             });
             throw error;
           }
@@ -778,19 +971,68 @@ function wrapTools(tools, sessionId, client) {
   }
   return wrappedTools;
 }
-function wrapGenerateText(originalFn, client) {
+function wrapToolsAsync(tools, sessionPromise, client) {
+  const wrappedTools = {};
+  for (const [toolName, tool] of Object.entries(tools)) {
+    if (typeof tool.execute === "function") {
+      const originalExecute = tool.execute;
+      wrappedTools[toolName] = {
+        ...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(() => {
+              });
+            }
+            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(() => {
+              });
+            }
+            throw error;
+          }
+        }
+      };
+    } else {
+      wrappedTools[toolName] = tool;
+    }
+  }
+  return wrappedTools;
+}
+function wrapGenerateText(originalFn, client, config) {
   return async (params) => {
     const startTime = Date.now();
     const { modelId, provider } = extractModelInfo(params.model);
     const input = extractInput(params);
     const sessionId = await client.createSession({
       name: `generateText: ${input.slice(0, 50)}${input.length > 50 ? "..." : ""}`,
-      agentName: _globalConfig.defaultAgent ?? "vercel-ai-sdk",
-      userId: _globalConfig.userId ?? "anonymous",
+      agentName: config.defaultAgent ?? "vercel-ai-sdk",
+      userId: config.userId ?? "anonymous",
+      convoId: config.convoId,
       metadata: {
         model: modelId,
         provider,
-        function: "generateText"
+        function: "generateText",
+        ...params.maxSteps ? { maxSteps: params.maxSteps } : {}
       }
     });
     if (!sessionId) {
@@ -804,23 +1046,46 @@ function wrapGenerateText(originalFn, client) {
     try {
       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 cost = calculateCostForCall(provider, modelId, promptTokens, completionTokens);
-      await client.trackEvent({
-        sessionId,
-        eventType: "llm_call",
-        eventData: {
-          model: modelId,
-          provider,
-          prompt_tokens: promptTokens,
-          completion_tokens: completionTokens,
-          total_tokens: totalTokens,
-          finish_reason: result.finishReason,
-          tool_calls: result.toolCalls?.map((tc) => tc.toolName)
+      const cost = calculateCostForCall(provider, resolvedModelId, promptTokens, completionTokens);
+      const steps = result.steps;
+      if (steps && steps.length >= 1) {
+        for (let i = 0; i < steps.length; i++) {
+          const step = steps[i];
+          await client.trackEvent({
+            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,
+              tool_calls: step.toolCalls?.map((tc) => tc.toolName)
+            }
+          });
         }
-      });
+      } else {
+        await client.trackEvent({
+          sessionId,
+          eventType: "llm_call",
+          eventData: {
+            model: resolvedModelId,
+            provider,
+            prompt_tokens: promptTokens,
+            completion_tokens: completionTokens,
+            total_tokens: totalTokens,
+            finish_reason: result.finishReason,
+            tool_calls: result.toolCalls?.map((tc) => tc.toolName)
+          }
+        });
+      }
       await client.completeSession({
         sessionId,
         success: true,
@@ -849,134 +1114,140 @@ function wrapGenerateText(originalFn, client) {
     }
   };
 }
-function wrapStreamText(originalFn, client) {
+function wrapStreamText(originalFn, client, config) {
   return (params) => {
     const startTime = Date.now();
     const { modelId, provider } = extractModelInfo(params.model);
     const input = extractInput(params);
     let sessionId = null;
-    const sessionPromise = client.createSession({
-      name: `streamText: ${input.slice(0, 50)}${input.length > 50 ? "..." : ""}`,
-      agentName: _globalConfig.defaultAgent ?? "vercel-ai-sdk",
-      userId: _globalConfig.userId ?? "anonymous",
-      metadata: {
-        model: modelId,
-        provider,
-        function: "streamText"
+    const sessionPromise = (async () => {
+      try {
+        const id = await client.createSession({
+          name: `streamText: ${input.slice(0, 50)}${input.length > 50 ? "..." : ""}`,
+          agentName: config.defaultAgent ?? "vercel-ai-sdk",
+          userId: config.userId ?? "anonymous",
+          convoId: config.convoId,
+          metadata: {
+            model: modelId,
+            provider,
+            function: "streamText"
+          }
+        });
+        sessionId = id;
+        if (id) {
+          client.setInput(id, input).catch(() => {
+          });
+        }
+        return id;
+      } catch {
+        return null;
       }
-    }).then((id) => {
-      sessionId = id;
-      if (id) client.setInput(id, input);
-      return id;
-    });
+    })();
     const wrappedParams = {
       ...params,
       tools: params.tools ? wrapToolsAsync(params.tools, sessionPromise, client) : void 0
     };
     const result = originalFn(wrappedParams);
-    const originalTextStream = result.textStream;
-    let fullText = "";
-    result.textStream = (async function* () {
+    let tracked = false;
+    async function trackCompletion(fullText, 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"
+        });
+        await client.completeSession({
+          sessionId: sid,
+          success: false,
+          failureReason: error.message || "Unknown error",
+          durationMs
+        });
+        return;
+      }
+      let usage;
       try {
-        for await (const chunk of originalTextStream) {
-          fullText += chunk;
-          yield chunk;
-        }
-        const durationMs = Date.now() - startTime;
-        const sid = sessionId || await sessionPromise;
-        if (sid) {
-          const usage = result.usage ? await result.usage : void 0;
-          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: fullText,
-            durationMs,
-            estimatedCost: cost,
-            promptTokens,
-            completionTokens,
-            totalTokens
-          });
-        }
-      } catch (error) {
-        const durationMs = Date.now() - startTime;
-        const sid = sessionId || 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
-          });
-        }
-        throw error;
+        usage = result.usage ? await result.usage : void 0;
+      } catch {
       }
-    })();
-    return result;
-  };
-}
-function wrapToolsAsync(tools, sessionPromise, client) {
-  const wrappedTools = {};
-  for (const [toolName, tool] of Object.entries(tools)) {
-    if (typeof tool.execute === "function") {
-      const originalExecute = tool.execute;
-      wrappedTools[toolName] = {
-        ...tool,
-        execute: async (...args) => {
-          const startTime = Date.now();
-          const sessionId = await sessionPromise;
+      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
+        }
+      });
+      await client.completeSession({
+        sessionId: sid,
+        success: true,
+        output: fullText,
+        durationMs,
+        estimatedCost: cost,
+        promptTokens,
+        completionTokens,
+        totalTokens
+      });
+    }
+    const textProp = result.text;
+    if (typeof textProp === "string") {
+      trackCompletion(textProp).catch(() => {
+      });
+    } else if (textProp != null && typeof textProp.then === "function") {
+      textProp.then((text) => {
+        trackCompletion(text).catch(() => {
+        });
+      }).catch((err) => {
+        trackCompletion("", err instanceof Error ? err : new Error(String(err))).catch(() => {
+        });
+      });
+    } else {
+      const desc = Object.getOwnPropertyDescriptor(result, "textStream") ?? Object.getOwnPropertyDescriptor(Object.getPrototypeOf(result), "textStream");
+      const isWritable = !desc || desc.writable || desc.set;
+      if (isWritable) {
+        const originalTextStream = result.textStream;
+        let fullText = "";
+        result.textStream = (async function* () {
           try {
-            const result = await originalExecute(...args);
-            const durationMs = Date.now() - startTime;
-            if (sessionId) {
-              await client.trackToolCall({
-                sessionId,
-                toolName,
-                toolInput: args[0],
-                toolOutput: result,
-                reasoning: `Tool executed in ${durationMs}ms`
-              });
+            for await (const chunk of originalTextStream) {
+              fullText += chunk;
+              yield chunk;
             }
-            return result;
+            await trackCompletion(fullText);
           } catch (error) {
-            const durationMs = Date.now() - startTime;
-            if (sessionId) {
-              await client.trackToolCall({
-                sessionId,
-                toolName,
-                toolInput: args[0],
-                toolOutput: {},
-                toolError: { message: error instanceof Error ? error.message : "Unknown error" },
-                reasoning: `Tool failed after ${durationMs}ms`
-              });
-            }
+            await trackCompletion(
+              "",
+              error instanceof Error ? error : new Error(String(error))
+            );
             throw error;
           }
-        }
-      };
-    } else {
-      wrappedTools[toolName] = tool;
+        })();
+      }
     }
-  }
-  return wrappedTools;
+    return result;
+  };
 }
-function wrapGenerateObject(originalFn, client) {
+function wrapGenerateObject(originalFn, client, config) {
   return async (params) => {
     const startTime = Date.now();
     const { modelId, provider } = extractModelInfo(params.model);
     const input = extractInput(params);
     const sessionId = await client.createSession({
       name: `generateObject: ${input.slice(0, 50)}${input.length > 50 ? "..." : ""}`,
-      agentName: _globalConfig.defaultAgent ?? "vercel-ai-sdk",
-      userId: _globalConfig.userId ?? "anonymous",
+      agentName: config.defaultAgent ?? "vercel-ai-sdk",
+      userId: config.userId ?? "anonymous",
+      convoId: config.convoId,
       metadata: {
         model: modelId,
         provider,
@@ -990,10 +1261,11 @@ function wrapGenerateObject(originalFn, client) {
     try {
       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 cost = calculateCostForCall(provider, modelId, promptTokens, completionTokens);
+      const cost = calculateCostForCall(provider, resolvedModelId, promptTokens, completionTokens);
       await client.completeSession({
         sessionId,
         success: true,
@@ -1022,78 +1294,100 @@ function wrapGenerateObject(originalFn, client) {
     }
   };
 }
-function wrapStreamObject(originalFn, client) {
+function wrapStreamObject(originalFn, client, config) {
   return (params) => {
     const startTime = Date.now();
     const { modelId, provider } = extractModelInfo(params.model);
     const input = extractInput(params);
-    const sessionPromise = client.createSession({
-      name: `streamObject: ${input.slice(0, 50)}${input.length > 50 ? "..." : ""}`,
-      agentName: _globalConfig.defaultAgent ?? "vercel-ai-sdk",
-      userId: _globalConfig.userId ?? "anonymous",
-      metadata: {
-        model: modelId,
-        provider,
-        function: "streamObject"
+    const sessionPromise = (async () => {
+      try {
+        const id = await client.createSession({
+          name: `streamObject: ${input.slice(0, 50)}${input.length > 50 ? "..." : ""}`,
+          agentName: config.defaultAgent ?? "vercel-ai-sdk",
+          userId: config.userId ?? "anonymous",
+          convoId: config.convoId,
+          metadata: {
+            model: modelId,
+            provider,
+            function: "streamObject"
+          }
+        });
+        if (id) {
+          client.setInput(id, input).catch(() => {
+          });
+        }
+        return id;
+      } catch {
+        return null;
       }
-    }).then((id) => {
-      if (id) client.setInput(id, input);
-      return id;
-    });
+    })();
     const result = originalFn(params);
-    if (result.object) {
-      const originalObjectPromise = result.object;
-      result.object = originalObjectPromise.then(async (obj) => {
+    const objectProp = result.object;
+    if (objectProp && typeof objectProp.then === "function") {
+      objectProp.then(async (obj) => {
         const durationMs = Date.now() - startTime;
-        const sessionId = await sessionPromise;
-        if (sessionId) {
-          const usage = result.usage ? await result.usage : void 0;
-          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,
-            success: true,
-            output: JSON.stringify(obj),
-            durationMs,
-            estimatedCost: cost,
-            promptTokens,
-            completionTokens,
-            totalTokens
-          });
+        const sid = await sessionPromise;
+        if (!sid) return;
+        let usage;
+        try {
+          usage = result.usage ? await result.usage : void 0;
+        } catch {
         }
-        return obj;
+        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
+        });
       }).catch(async (error) => {
         const durationMs = Date.now() - startTime;
-        const sessionId = await sessionPromise;
-        if (sessionId) {
-          await client.trackError({
-            sessionId,
-            errorType: error instanceof Error ? error.name : "Error",
-            errorMessage: error instanceof Error ? error.message : "Unknown error"
-          });
-          await client.completeSession({
-            sessionId,
-            success: false,
-            failureReason: error instanceof Error ? error.message : "Unknown error",
-            durationMs
-          });
-        }
-        throw error;
+        const sid = await sessionPromise;
+        if (!sid) return;
+        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 result;
   };
 }
-function wrapAISDK(ai) {
-  const client = getClient2();
+function wrapAISDK(ai, options) {
+  const client = options?.client ?? getClient2();
+  const config = {
+    defaultAgent: options?.defaultAgent ?? _globalConfig.defaultAgent,
+    userId: options?.userId ?? _globalConfig.userId,
+    convoId: options?.convoId ?? _globalConfig.convoId
+  };
   return {
-    generateText: ai.generateText ? wrapGenerateText(ai.generateText, client) : wrapGenerateText(() => Promise.reject(new Error("generateText not available")), client),
-    streamText: ai.streamText ? wrapStreamText(ai.streamText, client) : wrapStreamText(() => ({ textStream: (async function* () {
-    })() }), client),
-    generateObject: ai.generateObject ? wrapGenerateObject(ai.generateObject, client) : wrapGenerateObject(() => Promise.reject(new Error("generateObject not available")), client),
-    streamObject: ai.streamObject ? wrapStreamObject(ai.streamObject, client) : wrapStreamObject(() => ({}), client)
+    generateText: ai.generateText ? wrapGenerateText(ai.generateText, client, config) : wrapGenerateText(
+      () => Promise.reject(new Error("generateText not available")),
+      client,
+      config
+    ),
+    streamText: ai.streamText ? wrapStreamText(ai.streamText, client, config) : wrapStreamText(() => ({ textStream: (async function* () {
+    })() }), client, config),
+    generateObject: ai.generateObject ? wrapGenerateObject(ai.generateObject, client, config) : wrapGenerateObject(
+      () => Promise.reject(new Error("generateObject not available")),
+      client,
+      config
+    ),
+    streamObject: ai.streamObject ? wrapStreamObject(ai.streamObject, client, config) : wrapStreamObject(() => ({}), client, config)
   };
 }
 
@@ -2138,7 +2432,12 @@ var Experiment = class {
   getSessionContext,
   getSystemPrompt,
   getVariantName,
+  hashValue,
   isExperimentMode,
+  redactPayload,
+  redactString,
+  redactValue,
+  replaceMatch,
   sentrial,
   setClient,
   setDefaultClient,