@sentrial/sdk 0.1.0 → 0.2.0

package/dist/index.cjs

@@ -22,17 +22,44 @@ var index_exports = {};
 __export(index_exports, {
   ApiError: () => ApiError,
   EventType: () => EventType,
+  Experiment: () => Experiment,
+  ExperimentRunTracker: () => ExperimentRunTracker,
   Interaction: () => Interaction,
   NetworkError: () => NetworkError,
   SentrialClient: () => SentrialClient,
   SentrialError: () => SentrialError,
+  SessionContext: () => SessionContext,
+  Tool: () => Tool,
+  TrackSession: () => TrackSession,
   ValidationError: () => ValidationError,
   begin: () => begin,
   calculateAnthropicCost: () => calculateAnthropicCost,
   calculateGoogleCost: () => calculateGoogleCost,
   calculateOpenAICost: () => calculateOpenAICost,
+  clearExperimentContext: () => clearExperimentContext,
+  clearSessionContext: () => clearSessionContext,
   configure: () => configure,
-  sentrial: () => sentrial
+  configureVercel: () => configureVercel,
+  getCurrentInteraction: () => getCurrentInteraction,
+  getCurrentSessionId: () => getCurrentSessionId,
+  getExperimentContext: () => getExperimentContext,
+  getExperimentId: () => getExperimentId,
+  getSessionContext: () => getSessionContext,
+  getSystemPrompt: () => getSystemPrompt,
+  getVariantName: () => getVariantName,
+  isExperimentMode: () => isExperimentMode,
+  sentrial: () => sentrial,
+  setClient: () => setClient,
+  setDefaultClient: () => setDefaultClient,
+  setExperimentContext: () => setExperimentContext,
+  setSessionContext: () => setSessionContext,
+  withSession: () => withSession,
+  withTool: () => withTool,
+  wrapAISDK: () => wrapAISDK,
+  wrapAnthropic: () => wrapAnthropic,
+  wrapGoogle: () => wrapGoogle,
+  wrapLLM: () => wrapLLM,
+  wrapOpenAI: () => wrapOpenAI
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -185,6 +212,12 @@ 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;
@@ -196,54 +229,83 @@ var SentrialClient = class {
     this.failSilently = config.failSilently ?? true;
   }
   /**
-   * Make an HTTP request with graceful error handling
+   * 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) {
-    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 = {};
+    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 controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+        let response;
         try {
-          errorData = JSON.parse(errorBody);
-        } catch {
+          response = await fetch(url, {
+            method,
+            headers,
+            body: body ? JSON.stringify(body) : void 0,
+            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 (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 error;
-      }
-      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;
       }
-      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
@@ -259,6 +321,9 @@ var SentrialClient = class {
       userId: params.userId,
       metadata: params.metadata
     };
+    if (params.parentSessionId) {
+      payload.parentSessionId = params.parentSessionId;
+    }
     const response = await this.safeRequest(
       "POST",
       `${this.apiUrl}/api/sdk/sessions`,
@@ -352,6 +417,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
    *
@@ -391,7 +492,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}`,
@@ -438,7 +540,8 @@ var SentrialClient = class {
       sessionId,
       eventId,
       userId: params.userId,
-      event: params.event
+      event: params.event,
+      userInput: params.input
     });
   }
   // Cost calculation static methods for convenience
@@ -459,6 +562,7 @@ var Interaction = class {
   success = true;
   failureReason;
   output;
+  userInput;
   degraded;
   constructor(config) {
     this.client = config.client;
@@ -466,6 +570,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;
   }
   /**
@@ -511,6 +616,7 @@ var Interaction = class {
       promptTokens: params.promptTokens,
       completionTokens: params.completionTokens,
       totalTokens: params.totalTokens,
+      userInput: this.userInput,
       assistantOutput: finalOutput
     });
   }
@@ -576,20 +682,1474 @@ 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
+  };
+}
+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) {
+  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";
+  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);
+    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");
+    return lastUserMessage?.content || 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;
+            await client.trackToolCall({
+              sessionId,
+              toolName,
+              toolInput: args[0],
+              toolOutput: result,
+              reasoning: `Tool executed in ${durationMs}ms`
+            });
+            return result;
+          } catch (error) {
+            const durationMs = Date.now() - startTime;
+            await client.trackToolCall({
+              sessionId,
+              toolName,
+              toolInput: args[0],
+              toolOutput: {},
+              toolError: { message: error instanceof Error ? error.message : "Unknown error" },
+              reasoning: `Tool failed after ${durationMs}ms`
+            });
+            throw error;
+          }
+        }
+      };
+    } else {
+      wrappedTools[toolName] = tool;
+    }
+  }
+  return wrappedTools;
+}
+function wrapGenerateText(originalFn, client) {
+  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",
+      metadata: {
+        model: modelId,
+        provider,
+        function: "generateText"
+      }
+    });
+    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 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)
+        }
+      });
+      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) {
+  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"
+      }
+    }).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* () {
+      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;
+      }
+    })();
+    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;
+          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`
+              });
+            }
+            return result;
+          } 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`
+              });
+            }
+            throw error;
+          }
+        }
+      };
+    } else {
+      wrappedTools[toolName] = tool;
+    }
+  }
+  return wrappedTools;
+}
+function wrapGenerateObject(originalFn, client) {
+  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",
+      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 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.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) {
+  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"
+      }
+    }).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 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
+          });
+        }
+        return obj;
+      }).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;
+      });
+    }
+    return result;
+  };
+}
+function wrapAISDK(ai) {
+  const client = getClient2();
+  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)
+  };
+}
+
+// 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;
+    }
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   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,
+  isExperimentMode,
+  sentrial,
+  setClient,
+  setDefaultClient,
+  setExperimentContext,
+  setSessionContext,
+  withSession,
+  withTool,
+  wrapAISDK,
+  wrapAnthropic,
+  wrapGoogle,
+  wrapLLM,
+  wrapOpenAI
 });
 //# sourceMappingURL=index.cjs.map