@sentrial/sdk 0.1.0 → 0.3.0

package/dist/index.js

@@ -67,26 +67,126 @@ var ValidationError = class extends SentrialError {
   }
 };
 
+// src/redact.ts
+import { createHash } from "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 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 }
@@ -147,65 +247,168 @@ var EventType = /* @__PURE__ */ ((EventType2) => {
 
 // src/client.ts
 var DEFAULT_API_URL = "https://api.sentrial.com";
+var MAX_RETRIES = 3;
+var INITIAL_BACKOFF_MS = 500;
+var MAX_BACKOFF_MS = 8e3;
+var BACKOFF_MULTIPLIER = 2;
+var RETRYABLE_STATUS_CODES = /* @__PURE__ */ new Set([408, 429, 500, 502, 503, 504]);
+var REQUEST_TIMEOUT_MS = 1e4;
 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;
+    }
   }
   /**
-   * Make an HTTP request with graceful error handling
+   * 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 safeRequest(method, url, body) {
-    try {
-      const headers = {
-        "Content-Type": "application/json"
-      };
-      if (this.apiKey) {
-        headers["Authorization"] = `Bearer ${this.apiKey}`;
-      }
-      const response = await fetch(url, {
-        method,
-        headers,
-        body: body ? JSON.stringify(body) : void 0
-      });
-      if (!response.ok) {
-        const errorBody = await response.text();
-        let errorData = {};
+  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 {
-          errorData = JSON.parse(errorBody);
-        } catch {
+          response = await fetch(`${this.apiUrl}/api/sdk/pii-config`, {
+            method: "GET",
+            headers,
+            signal: controller.signal
+          });
+        } finally {
+          clearTimeout(timeoutId);
         }
-        const error = new ApiError(
-          errorData.error?.message || `HTTP ${response.status}: ${response.statusText}`,
-          response.status,
-          errorData.error?.code
-        );
-        if (this.failSilently) {
-          console.warn(`Sentrial: Request failed (${method} ${url}):`, error.message);
-          return null;
+        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
+            };
+          }
         }
-        throw error;
+      } catch {
       }
-      return await response.json();
-    } catch (error) {
-      if (error instanceof SentrialError) {
-        throw error;
-      }
-      const networkError = new NetworkError(
-        error instanceof Error ? error.message : "Unknown network error",
-        error instanceof Error ? error : void 0
-      );
-      if (this.failSilently) {
-        console.warn(`Sentrial: Request failed (${method} ${url}):`, networkError.message);
-        return null;
+      this.piiConfigNeedsHydration = false;
+    })();
+    await this.piiHydrationPromise;
+  }
+  /**
+   * Make an HTTP request with retry logic and exponential backoff.
+   *
+   * Retries on transient failures (network errors, timeouts, 429/5xx).
+   * 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++) {
+      try {
+        const headers = {
+          "Content-Type": "application/json"
+        };
+        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;
+        try {
+          response = await fetch(url, {
+            method,
+            headers,
+            body: finalBody ? JSON.stringify(finalBody) : void 0,
+            signal: controller.signal
+          });
+        } finally {
+          clearTimeout(timeoutId);
+        }
+        if (RETRYABLE_STATUS_CODES.has(response.status) && attempt < MAX_RETRIES) {
+          await this.sleep(backoff);
+          backoff = Math.min(backoff * BACKOFF_MULTIPLIER, MAX_BACKOFF_MS);
+          continue;
+        }
+        if (!response.ok) {
+          const errorBody = await response.text();
+          let errorData = {};
+          try {
+            errorData = JSON.parse(errorBody);
+          } catch {
+          }
+          const error = new ApiError(
+            errorData.error?.message || `HTTP ${response.status}: ${response.statusText}`,
+            response.status,
+            errorData.error?.code
+          );
+          if (this.failSilently) {
+            console.warn(`Sentrial: Request failed (${method} ${url}):`, error.message);
+            return null;
+          }
+          throw error;
+        }
+        return await response.json();
+      } catch (error) {
+        if (error instanceof ApiError) {
+          throw error;
+        }
+        lastError = error instanceof Error ? error : new Error(String(error));
+        if (attempt < MAX_RETRIES) {
+          await this.sleep(backoff);
+          backoff = Math.min(backoff * BACKOFF_MULTIPLIER, MAX_BACKOFF_MS);
+          continue;
+        }
       }
-      throw networkError;
     }
+    const networkError = new NetworkError(
+      lastError?.message ?? "Unknown network error",
+      lastError
+    );
+    if (this.failSilently) {
+      console.warn(`Sentrial: Request failed after ${MAX_RETRIES + 1} attempts (${method} ${url}):`, networkError.message);
+      return null;
+    }
+    throw networkError;
+  }
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
   }
   /**
    * Create a new session
@@ -221,6 +424,12 @@ var SentrialClient = class {
       userId: params.userId,
       metadata: params.metadata
     };
+    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`,
@@ -314,6 +523,42 @@ var SentrialClient = class {
   updateState(key, value) {
     this.currentState[key] = value;
   }
+  /**
+   * Set the user input for a session
+   *
+   * @param sessionId - Session ID
+   * @param input - User input text
+   * @returns Updated session or null on error
+   */
+  async setInput(sessionId, input) {
+    return this.safeRequest(
+      "PATCH",
+      `${this.apiUrl}/api/sdk/sessions/${sessionId}`,
+      { userInput: input }
+    );
+  }
+  /**
+   * Track a generic event
+   *
+   * @param params - Event parameters
+   * @returns Event data or null on error
+   */
+  async trackEvent(params) {
+    const stateBefore = { ...this.currentState };
+    const payload = {
+      sessionId: params.sessionId,
+      eventType: params.eventType,
+      stateBefore,
+      stateAfter: { ...this.currentState }
+    };
+    if (params.eventData) {
+      Object.assign(payload, params.eventData);
+    }
+    if (params.metadata) {
+      payload.metadata = params.metadata;
+    }
+    return this.safeRequest("POST", `${this.apiUrl}/api/sdk/events`, payload);
+  }
   /**
    * Complete a session with performance metrics
    *
@@ -353,7 +598,8 @@ var SentrialClient = class {
     if (params.completionTokens !== void 0) payload.completionTokens = params.completionTokens;
     if (params.totalTokens !== void 0) payload.totalTokens = params.totalTokens;
     if (params.userInput !== void 0) payload.userInput = params.userInput;
-    if (params.assistantOutput !== void 0) payload.assistantOutput = params.assistantOutput;
+    const output = params.assistantOutput ?? params.output;
+    if (output !== void 0) payload.assistantOutput = output;
     return this.safeRequest(
       "PATCH",
       `${this.apiUrl}/api/sdk/sessions/${params.sessionId}`,
@@ -390,6 +636,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) {
@@ -400,7 +647,8 @@ var SentrialClient = class {
       sessionId,
       eventId,
       userId: params.userId,
-      event: params.event
+      event: params.event,
+      userInput: params.input
     });
   }
   // Cost calculation static methods for convenience
@@ -421,6 +669,7 @@ var Interaction = class {
   success = true;
   failureReason;
   output;
+  userInput;
   degraded;
   constructor(config) {
     this.client = config.client;
@@ -428,6 +677,7 @@ var Interaction = class {
     this.eventId = config.eventId;
     this.userId = config.userId;
     this.event = config.event;
+    this.userInput = config.userInput;
     this.degraded = config.sessionId === null;
   }
   /**
@@ -473,6 +723,7 @@ var Interaction = class {
       promptTokens: params.promptTokens,
       completionTokens: params.completionTokens,
       totalTokens: params.totalTokens,
+      userInput: this.userInput,
       assistantOutput: finalOutput
     });
   }
@@ -538,19 +789,1598 @@ var sentrial = {
   configure,
   begin
 };
+
+// src/vercel.ts
+var _defaultClient = null;
+var _globalConfig = {};
+function configureVercel(config) {
+  _defaultClient = new SentrialClient({
+    apiKey: config.apiKey,
+    apiUrl: config.apiUrl,
+    failSilently: config.failSilently ?? true
+  });
+  _globalConfig = {
+    defaultAgent: config.defaultAgent,
+    userId: config.userId,
+    convoId: config.convoId
+  };
+}
+function getClient2() {
+  if (!_defaultClient) {
+    _defaultClient = new SentrialClient();
+  }
+  return _defaultClient;
+}
+function extractModelInfo(model) {
+  const modelId = model.modelId || model.id || "unknown";
+  const provider = model.provider || guessProvider(modelId);
+  return { modelId, provider };
+}
+function guessProvider(modelId) {
+  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) {
+  const params = { model: modelId, inputTokens: promptTokens, outputTokens: completionTokens };
+  switch (provider.toLowerCase()) {
+    case "openai":
+      return calculateOpenAICost(params);
+    case "anthropic":
+      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;
+  }
+}
+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");
+    if (lastUserMessage) {
+      return typeof lastUserMessage.content === "string" ? lastUserMessage.content : JSON.stringify(lastUserMessage.content);
+    }
+    return JSON.stringify(params.messages);
+  }
+  return "";
+}
+function wrapTools(tools, sessionId, client) {
+  if (!tools) return void 0;
+  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();
+          try {
+            const result = await originalExecute(...args);
+            const durationMs = Date.now() - startTime;
+            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;
+            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;
+          }
+        }
+      };
+    } else {
+      wrappedTools[toolName] = tool;
+    }
+  }
+  return wrappedTools;
+}
+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: config.defaultAgent ?? "vercel-ai-sdk",
+      userId: config.userId ?? "anonymous",
+      convoId: config.convoId,
+      metadata: {
+        model: modelId,
+        provider,
+        function: "generateText",
+        ...params.maxSteps ? { maxSteps: params.maxSteps } : {}
+      }
+    });
+    if (!sessionId) {
+      return originalFn(params);
+    }
+    await client.setInput(sessionId, input);
+    const wrappedParams = {
+      ...params,
+      tools: wrapTools(params.tools, sessionId, 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, 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,
+        output: result.text,
+        durationMs,
+        estimatedCost: cost,
+        promptTokens,
+        completionTokens,
+        totalTokens
+      });
+      return result;
+    } catch (error) {
+      const durationMs = Date.now() - startTime;
+      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;
+    }
+  };
+}
+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 = (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;
+      }
+    })();
+    const wrappedParams = {
+      ...params,
+      tools: params.tools ? wrapToolsAsync(params.tools, sessionPromise, client) : void 0
+    };
+    const result = originalFn(wrappedParams);
+    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 {
+        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.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") {
+      const originalTextPromise = textProp;
+      result.text = originalTextPromise.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;
+  };
+}
+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: config.defaultAgent ?? "vercel-ai-sdk",
+      userId: config.userId ?? "anonymous",
+      convoId: config.convoId,
+      metadata: {
+        model: modelId,
+        provider,
+        function: "generateObject"
+      }
+    });
+    if (!sessionId) {
+      return originalFn(params);
+    }
+    await client.setInput(sessionId, input);
+    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, resolvedModelId, promptTokens, completionTokens);
+      await client.completeSession({
+        sessionId,
+        success: true,
+        output: JSON.stringify(result.object),
+        durationMs,
+        estimatedCost: cost,
+        promptTokens,
+        completionTokens,
+        totalTokens
+      });
+      return result;
+    } catch (error) {
+      const durationMs = Date.now() - startTime;
+      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;
+    }
+  };
+}
+function wrapStreamObject(originalFn, client, config) {
+  return (params) => {
+    const startTime = Date.now();
+    const { modelId, provider } = extractModelInfo(params.model);
+    const input = extractInput(params);
+    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;
+      }
+    })();
+    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 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
+          });
+        }
+        throw error;
+      });
+    }
+    return result;
+  };
+}
+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, 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)
+  };
+}
+
+// src/wrappers.ts
+var _currentSessionId = null;
+var _currentClient = null;
+var _defaultClient2 = null;
+function setSessionContext(sessionId, client) {
+  _currentSessionId = sessionId;
+  if (client) {
+    _currentClient = client;
+  }
+}
+function clearSessionContext() {
+  _currentSessionId = null;
+  _currentClient = null;
+}
+function getSessionContext() {
+  return _currentSessionId;
+}
+function setDefaultClient(client) {
+  _defaultClient2 = client;
+}
+function getTrackingClient() {
+  return _currentClient ?? _defaultClient2;
+}
+function wrapOpenAI(client, options = {}) {
+  const { trackWithoutSession = false } = options;
+  const chat = client.chat;
+  if (!chat?.completions?.create) {
+    console.warn("Sentrial: OpenAI client does not have chat.completions.create");
+    return client;
+  }
+  const originalCreate = chat.completions.create.bind(chat.completions);
+  chat.completions.create = async function(...args) {
+    const startTime = Date.now();
+    const params = args[0] ?? {};
+    const messages = params.messages ?? [];
+    const model = params.model ?? "unknown";
+    try {
+      const response = await originalCreate(...args);
+      const durationMs = Date.now() - startTime;
+      const promptTokens = response.usage?.prompt_tokens ?? 0;
+      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 cost = calculateOpenAICost({ model, inputTokens: promptTokens, outputTokens: completionTokens });
+      trackLLMCall({
+        provider: "openai",
+        model,
+        messages,
+        output: outputContent,
+        promptTokens,
+        completionTokens,
+        totalTokens,
+        cost,
+        durationMs,
+        trackWithoutSession
+      });
+      return response;
+    } catch (error) {
+      const durationMs = Date.now() - startTime;
+      trackLLMError({
+        provider: "openai",
+        model,
+        messages,
+        error,
+        durationMs,
+        trackWithoutSession
+      });
+      throw error;
+    }
+  };
+  return client;
+}
+function wrapAnthropic(client, options = {}) {
+  const { trackWithoutSession = false } = options;
+  const messages = client.messages;
+  if (!messages?.create) {
+    console.warn("Sentrial: Anthropic client does not have messages.create");
+    return client;
+  }
+  const originalCreate = messages.create.bind(messages);
+  messages.create = async function(...args) {
+    const startTime = Date.now();
+    const params = args[0] ?? {};
+    const inputMessages = params.messages ?? [];
+    const model = params.model ?? "unknown";
+    const system = params.system ?? "";
+    try {
+      const response = await originalCreate(...args);
+      const durationMs = Date.now() - startTime;
+      const promptTokens = response.usage?.input_tokens ?? 0;
+      const completionTokens = response.usage?.output_tokens ?? 0;
+      const totalTokens = promptTokens + completionTokens;
+      let outputContent = "";
+      if (response.content) {
+        for (const block of response.content) {
+          if (block.type === "text") {
+            outputContent += block.text;
+          }
+        }
+      }
+      const cost = calculateAnthropicCost({ model, inputTokens: promptTokens, outputTokens: completionTokens });
+      const fullMessages = system ? [{ role: "system", content: system }, ...inputMessages] : inputMessages;
+      trackLLMCall({
+        provider: "anthropic",
+        model,
+        messages: fullMessages,
+        output: outputContent,
+        promptTokens,
+        completionTokens,
+        totalTokens,
+        cost,
+        durationMs,
+        trackWithoutSession
+      });
+      return response;
+    } catch (error) {
+      const durationMs = Date.now() - startTime;
+      trackLLMError({
+        provider: "anthropic",
+        model,
+        messages: inputMessages,
+        error,
+        durationMs,
+        trackWithoutSession
+      });
+      throw error;
+    }
+  };
+  return client;
+}
+function wrapGoogle(model, options = {}) {
+  const { trackWithoutSession = false } = options;
+  const originalGenerate = model.generateContent;
+  if (!originalGenerate) {
+    console.warn("Sentrial: Google model does not have generateContent");
+    return model;
+  }
+  model.generateContent = async function(...args) {
+    const startTime = Date.now();
+    const contents = args[0];
+    const modelName = model.model ?? "gemini-unknown";
+    const messages = googleContentsToMessages(contents);
+    try {
+      const response = await originalGenerate.apply(model, args);
+      const durationMs = Date.now() - startTime;
+      let promptTokens = 0;
+      let completionTokens = 0;
+      if (response.usageMetadata) {
+        promptTokens = response.usageMetadata.promptTokenCount ?? 0;
+        completionTokens = response.usageMetadata.candidatesTokenCount ?? 0;
+      }
+      const totalTokens = promptTokens + completionTokens;
+      let outputContent = "";
+      try {
+        outputContent = response.response?.text() ?? "";
+      } catch {
+      }
+      const cost = calculateGoogleCost({ model: modelName, inputTokens: promptTokens, outputTokens: completionTokens });
+      trackLLMCall({
+        provider: "google",
+        model: modelName,
+        messages,
+        output: outputContent,
+        promptTokens,
+        completionTokens,
+        totalTokens,
+        cost,
+        durationMs,
+        trackWithoutSession
+      });
+      return response;
+    } catch (error) {
+      const durationMs = Date.now() - startTime;
+      trackLLMError({
+        provider: "google",
+        model: modelName,
+        messages,
+        error,
+        durationMs,
+        trackWithoutSession
+      });
+      throw error;
+    }
+  };
+  return model;
+}
+function googleContentsToMessages(contents) {
+  if (typeof contents === "string") {
+    return [{ role: "user", content: contents }];
+  }
+  if (Array.isArray(contents)) {
+    return contents.map((item) => {
+      if (typeof item === "string") {
+        return { role: "user", content: item };
+      }
+      if (item && typeof item === "object") {
+        return { role: item.role ?? "user", content: String(item.content ?? item) };
+      }
+      return { role: "user", content: String(item) };
+    });
+  }
+  return [{ role: "user", content: String(contents) }];
+}
+function wrapLLM(client, provider) {
+  if (provider === "openai" || client.chat?.completions?.create) {
+    return wrapOpenAI(client);
+  }
+  if (provider === "anthropic" || client.messages?.create) {
+    return wrapAnthropic(client);
+  }
+  if (provider === "google" || client.generateContent) {
+    return wrapGoogle(client);
+  }
+  console.warn("Sentrial: Unknown LLM client type. No auto-tracking applied.");
+  return client;
+}
+function trackLLMCall(params) {
+  const client = getTrackingClient();
+  if (!client) return;
+  const sessionId = _currentSessionId;
+  if (!sessionId && !params.trackWithoutSession) {
+    return;
+  }
+  if (sessionId) {
+    client.trackToolCall({
+      sessionId,
+      toolName: `llm:${params.provider}:${params.model}`,
+      toolInput: {
+        messages: params.messages,
+        model: params.model,
+        provider: params.provider
+      },
+      toolOutput: {
+        content: params.output,
+        tokens: {
+          prompt: params.promptTokens,
+          completion: params.completionTokens,
+          total: params.totalTokens
+        },
+        cost_usd: params.cost
+      },
+      reasoning: `LLM call to ${params.provider} ${params.model}`,
+      estimatedCost: params.cost,
+      tokenCount: params.totalTokens,
+      metadata: {
+        provider: params.provider,
+        model: params.model,
+        duration_ms: params.durationMs,
+        prompt_tokens: params.promptTokens,
+        completion_tokens: params.completionTokens
+      }
+    }).catch((err) => {
+      console.warn("Sentrial: Failed to track LLM call:", err.message);
+    });
+  }
+}
+function trackLLMError(params) {
+  const client = getTrackingClient();
+  if (!client) return;
+  const sessionId = _currentSessionId;
+  if (!sessionId && !params.trackWithoutSession) {
+    return;
+  }
+  if (sessionId) {
+    client.trackError({
+      sessionId,
+      errorMessage: params.error.message,
+      errorType: params.error.name,
+      toolName: `llm:${params.provider}:${params.model}`,
+      metadata: {
+        provider: params.provider,
+        model: params.model,
+        duration_ms: params.durationMs
+      }
+    }).catch((err) => {
+      console.warn("Sentrial: Failed to track LLM error:", err.message);
+    });
+  }
+}
+
+// src/decorators.ts
+var _defaultClient3 = null;
+var _currentInteraction = null;
+function getClient3() {
+  if (!_defaultClient3) {
+    try {
+      _defaultClient3 = new SentrialClient();
+      setDefaultClient(_defaultClient3);
+    } catch {
+      return null;
+    }
+  }
+  return _defaultClient3;
+}
+function setClient(client) {
+  _defaultClient3 = client;
+  setDefaultClient(client);
+}
+function getCurrentSessionId() {
+  return getSessionContext();
+}
+function getCurrentInteraction() {
+  return _currentInteraction;
+}
+function withTool(name, fn) {
+  const isAsync = fn.constructor.name === "AsyncFunction";
+  if (isAsync) {
+    return async function(...args) {
+      return trackToolAsync(name, fn, args);
+    };
+  } else {
+    return function(...args) {
+      return trackToolSync(name, fn, args);
+    };
+  }
+}
+async function trackToolAsync(toolName, fn, args) {
+  const startTime = Date.now();
+  const toolInput = buildToolInput(args);
+  const client = getClient3();
+  const sessionId = getSessionContext();
+  try {
+    const result = await fn(...args);
+    const durationMs = Date.now() - startTime;
+    if (client && sessionId) {
+      const toolOutput = serializeOutput(result);
+      client.trackToolCall({
+        sessionId,
+        toolName,
+        toolInput,
+        toolOutput,
+        metadata: { duration_ms: durationMs }
+      }).catch((err) => {
+        console.warn(`Sentrial: Failed to track tool ${toolName}:`, err.message);
+      });
+    }
+    return result;
+  } catch (error) {
+    const durationMs = Date.now() - startTime;
+    if (client && sessionId) {
+      client.trackError({
+        sessionId,
+        errorMessage: error.message,
+        errorType: error.name,
+        toolName,
+        stackTrace: error.stack,
+        metadata: { duration_ms: durationMs }
+      }).catch(() => {
+      });
+    }
+    throw error;
+  }
+}
+function trackToolSync(toolName, fn, args) {
+  const startTime = Date.now();
+  const toolInput = buildToolInput(args);
+  const client = getClient3();
+  const sessionId = getSessionContext();
+  try {
+    const result = fn(...args);
+    const durationMs = Date.now() - startTime;
+    if (client && sessionId) {
+      const toolOutput = serializeOutput(result);
+      client.trackToolCall({
+        sessionId,
+        toolName,
+        toolInput,
+        toolOutput,
+        metadata: { duration_ms: durationMs }
+      }).catch((err) => {
+        console.warn(`Sentrial: Failed to track tool ${toolName}:`, err.message);
+      });
+    }
+    return result;
+  } catch (error) {
+    const durationMs = Date.now() - startTime;
+    if (client && sessionId) {
+      client.trackError({
+        sessionId,
+        errorMessage: error.message,
+        errorType: error.name,
+        toolName,
+        stackTrace: error.stack,
+        metadata: { duration_ms: durationMs }
+      }).catch(() => {
+      });
+    }
+    throw error;
+  }
+}
+function withSession(agentName, fn, options = {}) {
+  return async function(...args) {
+    const client = getClient3();
+    if (!client) {
+      return fn(...args);
+    }
+    const { userId, userInput } = extractParams(args, options);
+    const interaction = await client.begin({
+      userId,
+      event: agentName,
+      input: userInput
+    });
+    const sessionId = interaction.getSessionId();
+    if (sessionId) {
+      setSessionContext(sessionId, client);
+    }
+    _currentInteraction = interaction;
+    try {
+      const result = await fn(...args);
+      let output;
+      if (typeof result === "string") {
+        output = result;
+      } else if (result && typeof result === "object") {
+        if ("response" in result) {
+          output = String(result.response);
+        } else if ("output" in result) {
+          output = String(result.output);
+        }
+      }
+      if (output === void 0 && result !== null && result !== void 0) {
+        output = String(result).slice(0, 1e3);
+      }
+      await interaction.finish({ output, success: true });
+      return result;
+    } catch (error) {
+      await interaction.finish({
+        success: false,
+        failureReason: `${error.name}: ${error.message}`
+      });
+      throw error;
+    } finally {
+      clearSessionContext();
+      _currentInteraction = null;
+    }
+  };
+}
+function extractParams(args, options) {
+  let userId = "anonymous";
+  let userInput;
+  if (typeof options.userIdParam === "number") {
+    userId = String(args[options.userIdParam] ?? "anonymous");
+  } else if (typeof options.userIdParam === "string") {
+    userId = String(args[0] ?? "anonymous");
+  } else {
+    userId = String(args[0] ?? "anonymous");
+  }
+  if (typeof options.inputParam === "number") {
+    userInput = String(args[options.inputParam] ?? "");
+  } else {
+    const input = args[1];
+    if (typeof input === "string") {
+      userInput = input;
+    } else if (Array.isArray(input)) {
+      userInput = JSON.stringify(input).slice(0, 500);
+    }
+  }
+  return { userId, userInput };
+}
+function Tool(name) {
+  return function(_target, propertyKey, descriptor) {
+    const originalMethod = descriptor.value;
+    const toolName = name ?? String(propertyKey);
+    descriptor.value = async function(...args) {
+      const startTime = Date.now();
+      const toolInput = buildToolInput(args);
+      const client = getClient3();
+      const sessionId = getSessionContext();
+      try {
+        const result = await originalMethod.apply(this, args);
+        const durationMs = Date.now() - startTime;
+        if (client && sessionId) {
+          const toolOutput = serializeOutput(result);
+          client.trackToolCall({
+            sessionId,
+            toolName,
+            toolInput,
+            toolOutput,
+            metadata: { duration_ms: durationMs }
+          }).catch((err) => {
+            console.warn(`Sentrial: Failed to track tool ${toolName}:`, err.message);
+          });
+        }
+        return result;
+      } catch (error) {
+        const durationMs = Date.now() - startTime;
+        if (client && sessionId) {
+          client.trackError({
+            sessionId,
+            errorMessage: error.message,
+            errorType: error.name,
+            toolName,
+            stackTrace: error.stack,
+            metadata: { duration_ms: durationMs }
+          }).catch(() => {
+          });
+        }
+        throw error;
+      }
+    };
+    return descriptor;
+  };
+}
+function TrackSession(agentName, options) {
+  return function(target, _propertyKey, descriptor) {
+    const originalMethod = descriptor.value;
+    const agent = agentName ?? target.constructor.name;
+    descriptor.value = async function(...args) {
+      const client = getClient3();
+      if (!client) {
+        return originalMethod.apply(this, args);
+      }
+      const { userId, userInput } = extractParams(args, options ?? {});
+      const interaction = await client.begin({
+        userId,
+        event: agent,
+        input: userInput
+      });
+      const sessionId = interaction.getSessionId();
+      if (sessionId) {
+        setSessionContext(sessionId, client);
+      }
+      _currentInteraction = interaction;
+      try {
+        const result = await originalMethod.apply(this, args);
+        let output;
+        if (typeof result === "string") {
+          output = result;
+        } else if (result && typeof result === "object") {
+          if ("response" in result) {
+            output = String(result.response);
+          } else if ("output" in result) {
+            output = String(result.output);
+          }
+        }
+        if (output === void 0 && result !== null && result !== void 0) {
+          output = String(result).slice(0, 1e3);
+        }
+        await interaction.finish({ output, success: true });
+        return result;
+      } catch (error) {
+        await interaction.finish({
+          success: false,
+          failureReason: `${error.name}: ${error.message}`
+        });
+        throw error;
+      } finally {
+        clearSessionContext();
+        _currentInteraction = null;
+      }
+    };
+    return descriptor;
+  };
+}
+var SessionContext = class {
+  userId;
+  agent;
+  input;
+  client;
+  interaction = null;
+  output;
+  constructor(options) {
+    this.userId = options.userId;
+    this.agent = options.agent;
+    this.input = options.input;
+    this.client = options.client ?? getClient3();
+  }
+  /**
+   * Start the session
+   */
+  async start() {
+    if (!this.client) return this;
+    this.interaction = await this.client.begin({
+      userId: this.userId,
+      event: this.agent,
+      input: this.input
+    });
+    const sessionId = this.interaction.getSessionId();
+    if (sessionId) {
+      setSessionContext(sessionId, this.client);
+    }
+    _currentInteraction = this.interaction;
+    return this;
+  }
+  /**
+   * Set the output for this session
+   */
+  setOutput(output) {
+    this.output = output;
+  }
+  /**
+   * Finish the session
+   */
+  async finish(options) {
+    if (this.interaction) {
+      await this.interaction.finish({
+        output: this.output,
+        success: options?.success ?? true,
+        failureReason: options?.error
+      });
+    }
+    clearSessionContext();
+    _currentInteraction = null;
+  }
+  /**
+   * Get the session ID
+   */
+  get sessionId() {
+    return this.interaction?.getSessionId() ?? null;
+  }
+};
+function buildToolInput(args) {
+  if (args.length === 0) {
+    return {};
+  }
+  if (args.length === 1 && typeof args[0] === "object" && args[0] !== null) {
+    return serializeValue(args[0]);
+  }
+  return {
+    args: args.map(serializeValue)
+  };
+}
+function serializeValue(value) {
+  if (value === null || value === void 0) {
+    return value;
+  }
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map(serializeValue);
+  }
+  if (typeof value === "object") {
+    const result = {};
+    for (const [k, v] of Object.entries(value)) {
+      result[k] = serializeValue(v);
+    }
+    return result;
+  }
+  try {
+    return String(value).slice(0, 1e3);
+  } catch {
+    return `<${typeof value}>`;
+  }
+}
+function serializeOutput(value) {
+  if (value === null || value === void 0) {
+    return { result: null };
+  }
+  if (typeof value === "object" && !Array.isArray(value)) {
+    return serializeValue(value);
+  }
+  return { result: serializeValue(value) };
+}
+
+// src/context.ts
+var _experimentContext = null;
+function getSystemPrompt(defaultPrompt) {
+  if (_experimentContext?.systemPrompt) {
+    return _experimentContext.systemPrompt;
+  }
+  return defaultPrompt ?? "";
+}
+function getExperimentContext() {
+  return _experimentContext;
+}
+function isExperimentMode() {
+  return _experimentContext !== null;
+}
+function getVariantName() {
+  return _experimentContext?.variantName ?? null;
+}
+function getExperimentId() {
+  return _experimentContext?.experimentId ?? null;
+}
+function setExperimentContext(context) {
+  _experimentContext = context;
+}
+function clearExperimentContext() {
+  _experimentContext = null;
+}
+
+// src/experiment.ts
+var ExperimentRunTracker = class {
+  experiment;
+  variantName;
+  baseSessionId;
+  runId;
+  resultSessionId;
+  _success = true;
+  _errorMessage;
+  /** @internal */
+  constructor(experiment, variantName, baseSessionId) {
+    this.experiment = experiment;
+    this.variantName = variantName;
+    this.baseSessionId = baseSessionId;
+  }
+  /**
+   * Start the run - creates a run record via API.
+   */
+  async start() {
+    try {
+      const response = await this.experiment.request(
+        "POST",
+        `/api/experiments/${this.experiment.experimentId}/runs`,
+        {
+          variantName: this.variantName,
+          baseSessionId: this.baseSessionId
+        }
+      );
+      this.runId = response?.run?.id;
+    } catch {
+    }
+    return this;
+  }
+  /**
+   * Set the session ID of the result session.
+   */
+  setResultSessionId(sessionId) {
+    this.resultSessionId = sessionId;
+  }
+  /**
+   * Mark the run as complete.
+   */
+  async complete() {
+    if (!this.runId) return;
+    try {
+      await this.experiment.request(
+        "PATCH",
+        `/api/experiments/${this.experiment.experimentId}/runs/${this.runId}`,
+        {
+          status: "completed",
+          resultSessionId: this.resultSessionId
+        }
+      );
+    } catch {
+    }
+  }
+  /**
+   * Mark the run as failed.
+   */
+  async fail(errorMessage) {
+    this._success = false;
+    this._errorMessage = errorMessage;
+    if (!this.runId) return;
+    try {
+      await this.experiment.request(
+        "PATCH",
+        `/api/experiments/${this.experiment.experimentId}/runs/${this.runId}`,
+        {
+          status: "failed",
+          resultSessionId: this.resultSessionId,
+          errorMessage
+        }
+      );
+    } catch {
+    }
+  }
+  /**
+   * Get the result of this run.
+   */
+  getResult() {
+    return {
+      variantName: this.variantName,
+      testCaseSessionId: this.baseSessionId,
+      resultSessionId: this.resultSessionId,
+      success: this._success,
+      errorMessage: this._errorMessage
+    };
+  }
+};
+var Experiment = class {
+  /** The experiment ID */
+  experimentId;
+  /** @internal */
+  client;
+  /** @internal */
+  apiUrl;
+  /** @internal */
+  apiKey;
+  config;
+  _variants;
+  _testCases;
+  /**
+   * Create an experiment instance.
+   *
+   * @param experimentId - The experiment ID from Sentrial dashboard
+   * @param options - Configuration options
+   */
+  constructor(experimentId, options = {}) {
+    this.experimentId = experimentId;
+    this.apiUrl = (options.apiUrl ?? (typeof process !== "undefined" ? process.env?.SENTRIAL_API_URL : void 0) ?? "https://api.sentrial.com").replace(/\/$/, "");
+    this.apiKey = options.apiKey ?? (typeof process !== "undefined" ? process.env?.SENTRIAL_API_KEY : void 0);
+    this.client = new SentrialClient({
+      apiKey: this.apiKey,
+      apiUrl: this.apiUrl,
+      failSilently: false
+      // We want errors for experiments
+    });
+  }
+  /**
+   * Make an HTTP request to the API
+   * @internal
+   */
+  async request(method, path, body) {
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (this.apiKey) {
+      headers["Authorization"] = `Bearer ${this.apiKey}`;
+    }
+    const response = await fetch(`${this.apiUrl}${path}`, {
+      method,
+      headers,
+      body: body ? JSON.stringify(body) : void 0
+    });
+    if (!response.ok) {
+      return null;
+    }
+    return response.json();
+  }
+  /**
+   * Load the experiment configuration from the API.
+   */
+  async load() {
+    const response = await this.request(
+      "GET",
+      `/api/experiments/${this.experimentId}/runs`
+    );
+    if (!response?.experiment) {
+      throw new Error(`Failed to load experiment config for ${this.experimentId}`);
+    }
+    this.config = response.experiment;
+    const variants = this.config.variants;
+    this._variants = variants?.map((v) => ({
+      name: v.name ?? "",
+      systemPrompt: v.systemPrompt ?? "",
+      description: v.description
+    })) ?? [];
+    const testCases = this.config.testCases;
+    this._testCases = testCases?.filter((tc) => tc.userInput)?.map((tc) => ({
+      sessionId: tc.sessionId ?? "",
+      userInput: tc.userInput ?? ""
+    })) ?? [];
+    return this;
+  }
+  /**
+   * Get experiment name.
+   */
+  get name() {
+    return this.config?.name ?? "";
+  }
+  /**
+   * Get experiment status.
+   */
+  get status() {
+    return this.config?.status ?? "";
+  }
+  /**
+   * Get list of variants to test.
+   */
+  get variants() {
+    if (!this._variants) {
+      throw new Error("Experiment not loaded. Call load() first.");
+    }
+    return this._variants;
+  }
+  /**
+   * Get list of test cases.
+   */
+  get testCases() {
+    if (!this._testCases) {
+      throw new Error("Experiment not loaded. Call load() first.");
+    }
+    return this._testCases;
+  }
+  /**
+   * Get a specific variant by name.
+   */
+  getVariant(name) {
+    return this.variants.find((v) => v.name === name);
+  }
+  /**
+   * Create a run tracker for manual experiment runs.
+   */
+  async trackRun(variantName, baseSessionId) {
+    const tracker = new ExperimentRunTracker(this, variantName, baseSessionId);
+    await tracker.start();
+    return tracker;
+  }
+  /**
+   * Run the experiment with all variants and test cases.
+   *
+   * @param agentFn - Function that runs your agent with a test case and variant
+   * @param options - Run options
+   * @returns List of run results
+   */
+  async run(agentFn, options = {}) {
+    const { parallel = false, maxWorkers = 4 } = options;
+    if (!this._variants || !this._testCases) {
+      await this.load();
+    }
+    const results = [];
+    const totalRuns = this.variants.length * this.testCases.length;
+    let completed = 0;
+    console.log(`Running experiment: ${this.name || this.experimentId}`);
+    console.log(`  Variants: ${this.variants.length}`);
+    console.log(`  Test cases: ${this.testCases.length}`);
+    console.log(`  Total runs: ${totalRuns}`);
+    console.log();
+    const runSingle = async (variant, testCase) => {
+      const tracker = await this.trackRun(variant.name, testCase.sessionId);
+      setExperimentContext({
+        systemPrompt: variant.systemPrompt,
+        variantName: variant.name,
+        experimentId: this.experimentId,
+        testCaseId: testCase.sessionId
+      });
+      try {
+        await agentFn(testCase, variant, tracker);
+        await tracker.complete();
+        return tracker.getResult();
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        await tracker.fail(errorMessage);
+        return tracker.getResult();
+      } finally {
+        clearExperimentContext();
+      }
+    };
+    if (parallel) {
+      const queue = [];
+      for (const variant of this.variants) {
+        for (const testCase of this.testCases) {
+          queue.push(async () => {
+            const result = await runSingle(variant, testCase);
+            results.push(result);
+            completed++;
+            const status = result.success ? "\u2713" : "\u2717";
+            console.log(
+              `  [${completed}/${totalRuns}] ${status} ${variant.name} x ${testCase.sessionId.slice(0, 8)}...`
+            );
+          });
+        }
+      }
+      const executing = [];
+      for (const task of queue) {
+        const promise = task().then(() => {
+          executing.splice(executing.indexOf(promise), 1);
+        });
+        executing.push(promise);
+        if (executing.length >= maxWorkers) {
+          await Promise.race(executing);
+        }
+      }
+      await Promise.all(executing);
+    } else {
+      for (const variant of this.variants) {
+        for (const testCase of this.testCases) {
+          const result = await runSingle(variant, testCase);
+          results.push(result);
+          completed++;
+          const status = result.success ? "\u2713" : "\u2717";
+          console.log(
+            `  [${completed}/${totalRuns}] ${status} ${variant.name} x ${testCase.sessionId.slice(0, 8)}...`
+          );
+        }
+      }
+    }
+    console.log();
+    console.log("Experiment complete!");
+    console.log(`  Successful: ${results.filter((r) => r.success).length}/${totalRuns}`);
+    console.log(`  Failed: ${results.filter((r) => !r.success).length}/${totalRuns}`);
+    return results;
+  }
+  /**
+   * Reset all runs for this experiment (for re-running).
+   */
+  async reset() {
+    try {
+      const response = await this.request(
+        "DELETE",
+        `/api/experiments/${this.experimentId}/runs`
+      );
+      if (response !== null) {
+        this.config = void 0;
+        this._variants = void 0;
+        this._testCases = void 0;
+        return true;
+      }
+      return false;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Fetch aggregated results from the API.
+   */
+  async getResults() {
+    try {
+      const response = await this.request(
+        "GET",
+        `/api/experiments/${this.experimentId}/results`
+      );
+      return response;
+    } catch {
+      return null;
+    }
+  }
+};
 export {
   ApiError,
   EventType,
+  Experiment,
+  ExperimentRunTracker,
   Interaction,
   NetworkError,
   SentrialClient,
   SentrialError,
+  SessionContext,
+  Tool,
+  TrackSession,
   ValidationError,
   begin,
   calculateAnthropicCost,
   calculateGoogleCost,
   calculateOpenAICost,
+  clearExperimentContext,
+  clearSessionContext,
   configure,
-  sentrial
+  configureVercel,
+  getCurrentInteraction,
+  getCurrentSessionId,
+  getExperimentContext,
+  getExperimentId,
+  getSessionContext,
+  getSystemPrompt,
+  getVariantName,
+  hashValue,
+  isExperimentMode,
+  redactPayload,
+  redactString,
+  redactValue,
+  replaceMatch,
+  sentrial,
+  setClient,
+  setDefaultClient,
+  setExperimentContext,
+  setSessionContext,
+  withSession,
+  withTool,
+  wrapAISDK,
+  wrapAnthropic,
+  wrapGoogle,
+  wrapLLM,
+  wrapOpenAI
 };
 //# sourceMappingURL=index.js.map