echo-ai-sdk-ts 2.2.0 → 2.4.0

package/dist/index.mjs

@@ -741,14 +741,14 @@ var require_url_state_machine = __commonJS({
       return url.replace(/\u0009|\u000A|\u000D/g, "");
     }
     function shortenPath(url) {
-      const path = url.path;
-      if (path.length === 0) {
+      const path2 = url.path;
+      if (path2.length === 0) {
         return;
       }
-      if (url.scheme === "file" && path.length === 1 && isNormalizedWindowsDriveLetter(path[0])) {
+      if (url.scheme === "file" && path2.length === 1 && isNormalizedWindowsDriveLetter(path2[0])) {
         return;
       }
-      path.pop();
+      path2.pop();
     }
     function includesCredentials(url) {
       return url.username !== "" || url.password !== "";
@@ -3016,7 +3016,7 @@ var require_ponyfill_es2018 = __commonJS({
         return new originalPromise(executor);
       }
       function promiseResolvedWith(value) {
-        return newPromise((resolve) => resolve(value));
+        return newPromise((resolve2) => resolve2(value));
       }
       function promiseRejectedWith(reason) {
         return originalPromiseReject(reason);
@@ -3186,8 +3186,8 @@ var require_ponyfill_es2018 = __commonJS({
         return new TypeError("Cannot " + name + " a stream using a released reader");
       }
       function defaultReaderClosedPromiseInitialize(reader) {
-        reader._closedPromise = newPromise((resolve, reject) => {
-          reader._closedPromise_resolve = resolve;
+        reader._closedPromise = newPromise((resolve2, reject) => {
+          reader._closedPromise_resolve = resolve2;
           reader._closedPromise_reject = reject;
         });
       }
@@ -3361,8 +3361,8 @@ var require_ponyfill_es2018 = __commonJS({
           }
           let resolvePromise;
           let rejectPromise;
-          const promise = newPromise((resolve, reject) => {
-            resolvePromise = resolve;
+          const promise = newPromise((resolve2, reject) => {
+            resolvePromise = resolve2;
             rejectPromise = reject;
           });
           const readRequest = {
@@ -3467,8 +3467,8 @@ var require_ponyfill_es2018 = __commonJS({
           const reader = this._reader;
           let resolvePromise;
           let rejectPromise;
-          const promise = newPromise((resolve, reject) => {
-            resolvePromise = resolve;
+          const promise = newPromise((resolve2, reject) => {
+            resolvePromise = resolve2;
             rejectPromise = reject;
           });
           const readRequest = {
@@ -4487,8 +4487,8 @@ var require_ponyfill_es2018 = __commonJS({
           }
           let resolvePromise;
           let rejectPromise;
-          const promise = newPromise((resolve, reject) => {
-            resolvePromise = resolve;
+          const promise = newPromise((resolve2, reject) => {
+            resolvePromise = resolve2;
             rejectPromise = reject;
           });
           const readIntoRequest = {
@@ -4800,10 +4800,10 @@ var require_ponyfill_es2018 = __commonJS({
           wasAlreadyErroring = true;
           reason = void 0;
         }
-        const promise = newPromise((resolve, reject) => {
+        const promise = newPromise((resolve2, reject) => {
           stream._pendingAbortRequest = {
             _promise: void 0,
-            _resolve: resolve,
+            _resolve: resolve2,
             _reject: reject,
             _reason: reason,
             _wasAlreadyErroring: wasAlreadyErroring
@@ -4820,9 +4820,9 @@ var require_ponyfill_es2018 = __commonJS({
         if (state === "closed" || state === "errored") {
           return promiseRejectedWith(new TypeError(`The stream (in ${state} state) is not in the writable state and cannot be closed`));
         }
-        const promise = newPromise((resolve, reject) => {
+        const promise = newPromise((resolve2, reject) => {
           const closeRequest = {
-            _resolve: resolve,
+            _resolve: resolve2,
             _reject: reject
           };
           stream._closeRequest = closeRequest;
@@ -4835,9 +4835,9 @@ var require_ponyfill_es2018 = __commonJS({
         return promise;
       }
       function WritableStreamAddWriteRequest(stream) {
-        const promise = newPromise((resolve, reject) => {
+        const promise = newPromise((resolve2, reject) => {
           const writeRequest = {
-            _resolve: resolve,
+            _resolve: resolve2,
             _reject: reject
           };
           stream._writeRequests.push(writeRequest);
@@ -5453,8 +5453,8 @@ var require_ponyfill_es2018 = __commonJS({
         return new TypeError("Cannot " + name + " a stream using a released writer");
       }
       function defaultWriterClosedPromiseInitialize(writer) {
-        writer._closedPromise = newPromise((resolve, reject) => {
-          writer._closedPromise_resolve = resolve;
+        writer._closedPromise = newPromise((resolve2, reject) => {
+          writer._closedPromise_resolve = resolve2;
           writer._closedPromise_reject = reject;
           writer._closedPromiseState = "pending";
         });
@@ -5490,8 +5490,8 @@ var require_ponyfill_es2018 = __commonJS({
         writer._closedPromiseState = "resolved";
       }
       function defaultWriterReadyPromiseInitialize(writer) {
-        writer._readyPromise = newPromise((resolve, reject) => {
-          writer._readyPromise_resolve = resolve;
+        writer._readyPromise = newPromise((resolve2, reject) => {
+          writer._readyPromise_resolve = resolve2;
           writer._readyPromise_reject = reject;
         });
         writer._readyPromiseState = "pending";
@@ -5578,7 +5578,7 @@ var require_ponyfill_es2018 = __commonJS({
         source._disturbed = true;
         let shuttingDown = false;
         let currentWrite = promiseResolvedWith(void 0);
-        return newPromise((resolve, reject) => {
+        return newPromise((resolve2, reject) => {
           let abortAlgorithm;
           if (signal !== void 0) {
             abortAlgorithm = () => {
@@ -5723,7 +5723,7 @@ var require_ponyfill_es2018 = __commonJS({
             if (isError) {
               reject(error);
             } else {
-              resolve(void 0);
+              resolve2(void 0);
             }
             return null;
           }
@@ -6004,8 +6004,8 @@ var require_ponyfill_es2018 = __commonJS({
         let branch1;
         let branch2;
         let resolveCancelPromise;
-        const cancelPromise = newPromise((resolve) => {
-          resolveCancelPromise = resolve;
+        const cancelPromise = newPromise((resolve2) => {
+          resolveCancelPromise = resolve2;
         });
         function pullAlgorithm() {
           if (reading) {
@@ -6096,8 +6096,8 @@ var require_ponyfill_es2018 = __commonJS({
         let branch1;
         let branch2;
         let resolveCancelPromise;
-        const cancelPromise = newPromise((resolve) => {
-          resolveCancelPromise = resolve;
+        const cancelPromise = newPromise((resolve2) => {
+          resolveCancelPromise = resolve2;
         });
         function forwardReaderError(thisReader) {
           uponRejection(thisReader._closedPromise, (r) => {
@@ -6877,8 +6877,8 @@ var require_ponyfill_es2018 = __commonJS({
           const writableHighWaterMark = ExtractHighWaterMark(writableStrategy, 1);
           const writableSizeAlgorithm = ExtractSizeAlgorithm(writableStrategy);
           let startPromise_resolve;
-          const startPromise = newPromise((resolve) => {
-            startPromise_resolve = resolve;
+          const startPromise = newPromise((resolve2) => {
+            startPromise_resolve = resolve2;
           });
           InitializeTransformStream(this, startPromise, writableHighWaterMark, writableSizeAlgorithm, readableHighWaterMark, readableSizeAlgorithm);
           SetUpTransformStreamDefaultControllerFromTransformer(this, transformer);
@@ -6971,8 +6971,8 @@ var require_ponyfill_es2018 = __commonJS({
         if (stream._backpressureChangePromise !== void 0) {
           stream._backpressureChangePromise_resolve();
         }
-        stream._backpressureChangePromise = newPromise((resolve) => {
-          stream._backpressureChangePromise_resolve = resolve;
+        stream._backpressureChangePromise = newPromise((resolve2) => {
+          stream._backpressureChangePromise_resolve = resolve2;
         });
         stream._backpressure = backpressure;
       }
@@ -7140,8 +7140,8 @@ var require_ponyfill_es2018 = __commonJS({
           return controller._finishPromise;
         }
         const readable = stream._readable;
-        controller._finishPromise = newPromise((resolve, reject) => {
-          controller._finishPromise_resolve = resolve;
+        controller._finishPromise = newPromise((resolve2, reject) => {
+          controller._finishPromise_resolve = resolve2;
           controller._finishPromise_reject = reject;
         });
         const cancelPromise = controller._cancelAlgorithm(reason);
@@ -7167,8 +7167,8 @@ var require_ponyfill_es2018 = __commonJS({
           return controller._finishPromise;
         }
         const readable = stream._readable;
-        controller._finishPromise = newPromise((resolve, reject) => {
-          controller._finishPromise_resolve = resolve;
+        controller._finishPromise = newPromise((resolve2, reject) => {
+          controller._finishPromise_resolve = resolve2;
           controller._finishPromise_reject = reject;
         });
         const flushPromise = controller._flushAlgorithm();
@@ -7198,8 +7198,8 @@ var require_ponyfill_es2018 = __commonJS({
           return controller._finishPromise;
         }
         const writable = stream._writable;
-        controller._finishPromise = newPromise((resolve, reject) => {
-          controller._finishPromise_resolve = resolve;
+        controller._finishPromise = newPromise((resolve2, reject) => {
+          controller._finishPromise_resolve = resolve2;
           controller._finishPromise_reject = reject;
         });
         const cancelPromise = controller._cancelAlgorithm(reason);
@@ -7391,7 +7391,7 @@ var AIModelGateway = class {
           }
           if (attempt < 3) {
             const backoffMs = Math.pow(attempt, 2) * 500;
-            await new Promise((resolve) => setTimeout(resolve, backoffMs));
+            await new Promise((resolve2) => setTimeout(resolve2, backoffMs));
           }
         }
       }
@@ -7424,7 +7424,7 @@ var AIModelGateway = class {
           }
           if (attempt < 3) {
             const backoffMs = Math.pow(attempt, 2) * 500;
-            await new Promise((resolve) => setTimeout(resolve, backoffMs));
+            await new Promise((resolve2) => setTimeout(resolve2, backoffMs));
           }
         }
       }
@@ -7819,7 +7819,7 @@ function consumeBody() {
   let accum = [];
   let accumBytes = 0;
   let abort = false;
-  return new Body.Promise(function(resolve, reject) {
+  return new Body.Promise(function(resolve2, reject) {
     let resTimeout;
     if (_this4.timeout) {
       resTimeout = setTimeout(function() {
@@ -7853,7 +7853,7 @@ function consumeBody() {
       }
       clearTimeout(resTimeout);
       try {
-        resolve(Buffer.concat(accum, accumBytes));
+        resolve2(Buffer.concat(accum, accumBytes));
       } catch (err) {
         reject(new FetchError(`Could not create Buffer from response body for ${_this4.url}: ${err.message}`, "system", err));
       }
@@ -8528,7 +8528,7 @@ function fetch3(url, opts) {
     throw new Error("native promise missing, set fetch.Promise to your favorite alternative");
   }
   Body.Promise = fetch3.Promise;
-  return new fetch3.Promise(function(resolve, reject) {
+  return new fetch3.Promise(function(resolve2, reject) {
     const request = new Request2(url, opts);
     const options = getNodeRequestOptions(request);
     const send = (options.protocol === "https:" ? https : http).request;
@@ -8661,7 +8661,7 @@ function fetch3(url, opts) {
               requestOpts.body = void 0;
               requestOpts.headers.delete("content-length");
             }
-            resolve(fetch3(new Request2(locationURL, requestOpts)));
+            resolve2(fetch3(new Request2(locationURL, requestOpts)));
             finalize();
             return;
         }
@@ -8682,7 +8682,7 @@ function fetch3(url, opts) {
       const codings = headers.get("Content-Encoding");
       if (!request.compress || request.method === "HEAD" || codings === null || res.statusCode === 204 || res.statusCode === 304) {
         response = new Response2(body, response_options);
-        resolve(response);
+        resolve2(response);
         return;
       }
       const zlibOptions = {
@@ -8692,7 +8692,7 @@ function fetch3(url, opts) {
       if (codings == "gzip" || codings == "x-gzip") {
         body = body.pipe(zlib.createGunzip(zlibOptions));
         response = new Response2(body, response_options);
-        resolve(response);
+        resolve2(response);
         return;
       }
       if (codings == "deflate" || codings == "x-deflate") {
@@ -8704,12 +8704,12 @@ function fetch3(url, opts) {
             body = body.pipe(zlib.createInflateRaw());
           }
           response = new Response2(body, response_options);
-          resolve(response);
+          resolve2(response);
         });
         raw.on("end", function() {
           if (!response) {
             response = new Response2(body, response_options);
-            resolve(response);
+            resolve2(response);
           }
         });
         return;
@@ -8717,11 +8717,11 @@ function fetch3(url, opts) {
       if (codings == "br" && typeof zlib.createBrotliDecompress === "function") {
         body = body.pipe(zlib.createBrotliDecompress());
         response = new Response2(body, response_options);
-        resolve(response);
+        resolve2(response);
         return;
       }
       response = new Response2(body, response_options);
-      resolve(response);
+      resolve2(response);
     });
     writeToStream(req, request);
   });
@@ -9084,13 +9084,13 @@ var MultipartBody = class {
 // node_modules/@anthropic-ai/sdk/_shims/node-runtime.mjs
 var import_ponyfill_es2018 = __toESM(require_ponyfill_es2018(), 1);
 var fileFromPathWarned = false;
-async function fileFromPath2(path, ...args) {
+async function fileFromPath2(path2, ...args) {
   const { fileFromPath: _fileFromPath } = await import("./fileFromPath-4L47H5QG.mjs");
   if (!fileFromPathWarned) {
-    console.warn(`fileFromPath is deprecated; use fs.createReadStream(${JSON.stringify(path)}) instead`);
+    console.warn(`fileFromPath is deprecated; use fs.createReadStream(${JSON.stringify(path2)}) instead`);
     fileFromPathWarned = true;
   }
-  return await _fileFromPath(path, ...args);
+  return await _fileFromPath(path2, ...args);
 }
 var defaultHttpAgent = new import_agentkeepalive.default({ keepAlive: true, timeout: 5 * 60 * 1e3 });
 var defaultHttpsAgent = new import_agentkeepalive.default.HttpsAgent({ keepAlive: true, timeout: 5 * 60 * 1e3 });
@@ -9721,8 +9721,8 @@ async function defaultParseResponse(props) {
 }
 var APIPromise = class _APIPromise extends Promise {
   constructor(responsePromise, parseResponse = defaultParseResponse) {
-    super((resolve) => {
-      resolve(null);
+    super((resolve2) => {
+      resolve2(null);
     });
     this.responsePromise = responsePromise;
     this.parseResponse = parseResponse;
@@ -9822,26 +9822,26 @@ var APIClient = class {
   defaultIdempotencyKey() {
     return `stainless-node-retry-${uuid4()}`;
   }
-  get(path, opts) {
-    return this.methodRequest("get", path, opts);
+  get(path2, opts) {
+    return this.methodRequest("get", path2, opts);
   }
-  post(path, opts) {
-    return this.methodRequest("post", path, opts);
+  post(path2, opts) {
+    return this.methodRequest("post", path2, opts);
   }
-  patch(path, opts) {
-    return this.methodRequest("patch", path, opts);
+  patch(path2, opts) {
+    return this.methodRequest("patch", path2, opts);
   }
-  put(path, opts) {
-    return this.methodRequest("put", path, opts);
+  put(path2, opts) {
+    return this.methodRequest("put", path2, opts);
   }
-  delete(path, opts) {
-    return this.methodRequest("delete", path, opts);
+  delete(path2, opts) {
+    return this.methodRequest("delete", path2, opts);
   }
-  methodRequest(method, path, opts) {
-    return this.request(Promise.resolve(opts).then((opts2) => ({ method, path, ...opts2 })));
+  methodRequest(method, path2, opts) {
+    return this.request(Promise.resolve(opts).then((opts2) => ({ method, path: path2, ...opts2 })));
   }
-  getAPIList(path, Page, opts) {
-    return this.requestAPIList(Page, { method: "get", path, ...opts });
+  getAPIList(path2, Page, opts) {
+    return this.requestAPIList(Page, { method: "get", path: path2, ...opts });
   }
   calculateContentLength(body) {
     if (typeof body === "string") {
@@ -9857,10 +9857,10 @@ var APIClient = class {
     return null;
   }
   buildRequest(options) {
-    const { method, path, query, headers = {} } = options;
+    const { method, path: path2, query, headers = {} } = options;
     const body = isMultipartBody(options.body) ? options.body.body : options.body ? JSON.stringify(options.body, null, 2) : null;
     const contentLength = this.calculateContentLength(body);
-    const url = this.buildURL(path, query);
+    const url = this.buildURL(path2, query);
     if ("timeout" in options)
       validatePositiveInteger("timeout", options.timeout);
     const timeout = options.timeout ?? this.timeout;
@@ -9969,8 +9969,8 @@ var APIClient = class {
     const request = this.makeRequest(options, null);
     return new PagePromise(this, request, Page);
   }
-  buildURL(path, query) {
-    const url = isAbsoluteURL(path) ? new URL(path) : new URL(this.baseURL + (this.baseURL.endsWith("/") && path.startsWith("/") ? path.slice(1) : path));
+  buildURL(path2, query) {
+    const url = isAbsoluteURL(path2) ? new URL(path2) : new URL(this.baseURL + (this.baseURL.endsWith("/") && path2.startsWith("/") ? path2.slice(1) : path2));
     const defaultQuery = this.defaultQuery();
     if (!isEmptyObj(defaultQuery)) {
       query = { ...defaultQuery, ...query };
@@ -10255,7 +10255,7 @@ var startsWithSchemeRegexp = new RegExp("^(?:[a-z]+:)?//", "i");
 var isAbsoluteURL = (url) => {
   return startsWithSchemeRegexp.test(url);
 };
-var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var sleep = (ms) => new Promise((resolve2) => setTimeout(resolve2, ms));
 var validatePositiveInteger = (name, n) => {
   if (typeof n !== "number" || !Number.isInteger(n)) {
     throw new AnthropicError(`${name} must be an integer`);
@@ -10448,12 +10448,12 @@ var MessageStream = class _MessageStream {
       }
       return this._emit("error", new AnthropicError(String(error)));
     });
-    __classPrivateFieldSet3(this, _MessageStream_connectedPromise, new Promise((resolve, reject) => {
-      __classPrivateFieldSet3(this, _MessageStream_resolveConnectedPromise, resolve, "f");
+    __classPrivateFieldSet3(this, _MessageStream_connectedPromise, new Promise((resolve2, reject) => {
+      __classPrivateFieldSet3(this, _MessageStream_resolveConnectedPromise, resolve2, "f");
       __classPrivateFieldSet3(this, _MessageStream_rejectConnectedPromise, reject, "f");
     }), "f");
-    __classPrivateFieldSet3(this, _MessageStream_endPromise, new Promise((resolve, reject) => {
-      __classPrivateFieldSet3(this, _MessageStream_resolveEndPromise, resolve, "f");
+    __classPrivateFieldSet3(this, _MessageStream_endPromise, new Promise((resolve2, reject) => {
+      __classPrivateFieldSet3(this, _MessageStream_resolveEndPromise, resolve2, "f");
       __classPrivateFieldSet3(this, _MessageStream_rejectEndPromise, reject, "f");
     }), "f");
     __classPrivateFieldGet4(this, _MessageStream_connectedPromise, "f").catch(() => {
@@ -10582,11 +10582,11 @@ var MessageStream = class _MessageStream {
    *   const message = await stream.emitted('message') // rejects if the stream errors
    */
   emitted(event) {
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       __classPrivateFieldSet3(this, _MessageStream_catchingPromiseCreated, true, "f");
       if (event !== "error")
         this.once("error", reject);
-      this.once(event, resolve);
+      this.once(event, resolve2);
     });
   }
   async done() {
@@ -10797,7 +10797,7 @@ var MessageStream = class _MessageStream {
           if (done) {
             return { value: void 0, done: true };
           }
-          return new Promise((resolve, reject) => readQueue.push({ resolve, reject })).then((chunk2) => chunk2 ? { value: chunk2, done: false } : { value: void 0, done: true });
+          return new Promise((resolve2, reject) => readQueue.push({ resolve: resolve2, reject })).then((chunk2) => chunk2 ? { value: chunk2, done: false } : { value: void 0, done: true });
         }
         const chunk = pushQueue.shift();
         return { value: chunk, done: false };
@@ -11068,6 +11068,9 @@ var AgentExecutor = class {
     this.systemPrompt = options.systemPrompt;
     this.telemetry = options.telemetry;
   }
+  getMemory() {
+    return this.memory;
+  }
   async execute(sessionId, userInput, maxIterations = 5) {
     if (!sessionId) throw new ValidationError("execute", "sessionId is required.");
     if (!userInput) throw new ValidationError("execute", "userInput is required.");
@@ -13127,14 +13130,14 @@ var MemoryVectorStore = class {
     return scored.filter((e) => e.score >= minScore).sort((a, b) => b.score - a.score).slice(0, k);
   }
   /** Save the entire store to a JSON file. */
-  async saveToFile(path) {
+  async saveToFile(path2) {
     const data = JSON.stringify(this.entries);
-    await fs.writeFile(path, data, "utf8");
+    await fs.writeFile(path2, data, "utf8");
   }
   /** Load store entries from a JSON file. */
-  async loadFromFile(path) {
+  async loadFromFile(path2) {
     try {
-      const data = await fs.readFile(path, "utf8");
+      const data = await fs.readFile(path2, "utf8");
       this.entries = JSON.parse(data);
     } catch (e) {
       if (e.code !== "ENOENT") throw e;
@@ -13230,11 +13233,11 @@ var KnowledgeBase = class {
     if (results.length === 0) return "";
     return results.map((r, i) => `[Source ${i + 1} (${(r.score * 100).toFixed(0)}% match)]: ${r.content}`).join("\n\n");
   }
-  async save(path) {
-    await this.store.saveToFile(path);
+  async save(path2) {
+    await this.store.saveToFile(path2);
   }
-  async load(path) {
-    await this.store.loadFromFile(path);
+  async load(path2) {
+    await this.store.loadFromFile(path2);
   }
   async embed(text) {
     const res = await this.openai.embeddings.create({ model: this.embeddingModel, input: text });
@@ -13255,6 +13258,10 @@ var OPENAI_PRICING = {
 var ConversationAnalytics = class {
   records = /* @__PURE__ */ new Map();
   queryFrequency = /* @__PURE__ */ new Map();
+  outcomeTracker;
+  constructor(outcomeTracker) {
+    this.outcomeTracker = outcomeTracker;
+  }
   estimateTokens(text) {
     return Math.ceil(text.length / 4);
   }
@@ -13263,7 +13270,7 @@ var ConversationAnalytics = class {
     const rate = type === "input" ? pricing.input : pricing.output;
     return tokens / 1e6 * rate;
   }
-  startConversation(sessionId, model = "gpt-4o-mini") {
+  startConversation(sessionId, model = "gpt-4o-mini", variantId) {
     if (!this.records.has(sessionId)) {
       this.records.set(sessionId, {
         sessionId,
@@ -13275,7 +13282,8 @@ var ConversationAnalytics = class {
         totalCostUsd: 0,
         topQueries: [],
         responseTimes: [],
-        model
+        model,
+        variantId
       });
     }
   }
@@ -13332,10 +13340,39 @@ var ConversationAnalytics = class {
     const avgResponseTime = allResponseTimes.length > 0 ? allResponseTimes.reduce((a, b) => a + b, 0) / allResponseTimes.length : 0;
     const totalTokens = all.reduce((s, r) => s + r.totalTokens, 0);
     const totalCost = all.reduce((s, r) => s + r.totalCostUsd, 0);
+    let totalValue = 0;
+    if (this.outcomeTracker) {
+      totalValue = this.outcomeTracker.getGlobalStats().totalValueUsd;
+    }
     const now = Date.now();
     const firstConvo = all.length > 0 ? Math.min(...all.map((r) => r.startTime)) : now;
     const hourSpan = Math.max(1, (now - firstConvo) / 36e5);
     const topQueries = [...this.queryFrequency.entries()].sort((a, b) => b[1] - a[1]).slice(0, 20).map(([query, count]) => ({ query, count }));
+    const variants = {};
+    const groupedByVariant = all.reduce((acc, r) => {
+      const v = r.variantId || "default";
+      if (!acc[v]) acc[v] = [];
+      acc[v].push(r);
+      return acc;
+    }, {});
+    for (const [variantId, vRecords] of Object.entries(groupedByVariant)) {
+      const vTotal = vRecords.length;
+      const vResolved = vRecords.filter((r) => r.resolved).length;
+      let vValue = 0;
+      if (this.outcomeTracker) {
+        vRecords.forEach((r) => {
+          const outRecords = this.outcomeTracker.outcomes?.get(r.sessionId) || [];
+          vValue += outRecords.reduce((s, o) => s + o.valueUsd, 0);
+        });
+      }
+      const vCost = vRecords.reduce((s, r) => s + r.totalCostUsd, 0);
+      variants[variantId] = {
+        totalConversations: vTotal,
+        totalValueGeneratedUsd: vValue,
+        resolutionRate: vTotal > 0 ? vResolved / vTotal : 0,
+        roi: vCost > 0 ? (vValue - vCost) / vCost : 0
+      };
+    }
     return {
       totalConversations: total,
       resolvedCount: resolved,
@@ -13345,6 +13382,8 @@ var ConversationAnalytics = class {
       avgResponseTimeMs: Math.round(avgResponseTime),
       totalTokensUsed: totalTokens,
       totalCostUsd: Math.round(totalCost * 1e8) / 1e8,
+      totalValueGeneratedUsd: Math.round(totalValue * 100) / 100,
+      roi: totalCost > 0 ? (totalValue - totalCost) / totalCost : 0,
       avgTokensPerConversation: Math.round(totalTokens / total),
       avgCostPerConversation: Math.round(totalCost / total * 1e8) / 1e8,
       topQueries,
@@ -13361,6 +13400,8 @@ var ConversationAnalytics = class {
       avgResponseTimeMs: 0,
       totalTokensUsed: 0,
       totalCostUsd: 0,
+      totalValueGeneratedUsd: 0,
+      roi: 0,
       avgTokensPerConversation: 0,
       avgCostPerConversation: 0,
       topQueries: [],
@@ -13501,23 +13542,223 @@ var HandoffManager = class {
   }
 };
 
+// src/core/session.ts
+import * as fs2 from "fs/promises";
+import * as path from "path";
+var MemorySessionStore = class {
+  store = /* @__PURE__ */ new Map();
+  async get(sessionId) {
+    return this.store.get(sessionId) || null;
+  }
+  async set(sessionId, data) {
+    this.store.set(sessionId, data);
+  }
+  async delete(sessionId) {
+    this.store.delete(sessionId);
+  }
+  async clear() {
+    this.store.clear();
+  }
+};
+var FileSessionStore = class {
+  dir;
+  constructor(dir = "./.sessions") {
+    this.dir = path.resolve(dir);
+  }
+  getPath(sessionId) {
+    return path.join(this.dir, `${sessionId}.json`);
+  }
+  async ensureDir() {
+    try {
+      await fs2.mkdir(this.dir, { recursive: true });
+    } catch {
+    }
+  }
+  async get(sessionId) {
+    try {
+      const data = await fs2.readFile(this.getPath(sessionId), "utf8");
+      return JSON.parse(data);
+    } catch {
+      return null;
+    }
+  }
+  async set(sessionId, data) {
+    await this.ensureDir();
+    await fs2.writeFile(this.getPath(sessionId), JSON.stringify(data), "utf8");
+  }
+  async delete(sessionId) {
+    try {
+      await fs2.unlink(this.getPath(sessionId));
+    } catch {
+    }
+  }
+  async clear() {
+    try {
+      const files = await fs2.readdir(this.dir);
+      for (const file of files) {
+        if (file.endsWith(".json")) {
+          await fs2.unlink(path.join(this.dir, file));
+        }
+      }
+    } catch {
+    }
+  }
+};
+
+// src/analytics/outcome.ts
+var OutcomeTracker = class {
+  sessionOutcomes = /* @__PURE__ */ new Map();
+  /** Record a successful business outcome for a session. */
+  record(sessionId, type, valueUsd = 0, metadata) {
+    const list = this.sessionOutcomes.get(sessionId) || [];
+    list.push({ type, valueUsd, timestamp: Date.now(), metadata });
+    this.sessionOutcomes.set(sessionId, list);
+  }
+  /** Get all outcomes for a specific session. */
+  getSessionOutcomes(sessionId) {
+    return this.sessionOutcomes.get(sessionId) || [];
+  }
+  /** Calculate total value generated for a session. */
+  getSessionValue(sessionId) {
+    return this.getSessionOutcomes(sessionId).reduce((sum, o) => sum + o.valueUsd, 0);
+  }
+  /** Get global stats for all outcomes. */
+  getGlobalStats() {
+    const all = [...this.sessionOutcomes.values()].flat();
+    const totalValue = all.reduce((sum, o) => sum + o.valueUsd, 0);
+    const countByType = {};
+    for (const o of all) {
+      countByType[o.type] = (countByType[o.type] || 0) + 1;
+    }
+    return {
+      totalOutcomes: all.length,
+      totalValueUsd: totalValue,
+      outcomesByType: countByType
+    };
+  }
+  /** Reset all stats. */
+  clear() {
+    this.sessionOutcomes.clear();
+  }
+};
+
+// src/analytics/redact.ts
+var DEFAULT_REDACTION_RULES = [
+  {
+    name: "email",
+    pattern: /[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g,
+    placeholder: "[REDACTED_EMAIL]"
+  },
+  {
+    name: "phone",
+    pattern: /\b(?:\+?\d{1,3}[-.\s]?)?\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}\b/g,
+    placeholder: "[REDACTED_PHONE]"
+  },
+  {
+    name: "credit_card",
+    // Standard 16 digit match with optional dashes or spaces
+    pattern: /\b(?:\d[ -]*?){13,16}\b/g,
+    placeholder: "[REDACTED_CC]"
+  },
+  {
+    name: "ssn",
+    // Standard US SSN
+    pattern: /\b\d{3}[-.\s]?\d{2}[-.\s]?\d{4}\b/g,
+    placeholder: "[REDACTED_SSN]"
+  }
+];
+var PIIRedactor = class {
+  rules;
+  constructor(rules) {
+    this.rules = rules || DEFAULT_REDACTION_RULES;
+  }
+  /** Scans text and replaces any matched patterns with their placeholders. */
+  redact(text) {
+    if (!text) return text;
+    let redacted = text;
+    for (const rule of this.rules) {
+      redacted = redacted.replace(rule.pattern, rule.placeholder);
+    }
+    return redacted;
+  }
+  /** Adds custom redaction rules to the engine. */
+  addRule(rule) {
+    this.rules.push(rule);
+  }
+};
+
+// src/analytics/experiment.ts
+import * as crypto2 from "crypto";
+var ExperimentManager = class {
+  experiments = /* @__PURE__ */ new Map();
+  constructor(experiments) {
+    if (experiments) {
+      experiments.forEach((e) => this.registerExperiment(e));
+    }
+  }
+  registerExperiment(exp) {
+    this.experiments.set(exp.name, exp);
+  }
+  /**
+   * Assigns a user to a specific variant based on deterministic hashing of their sessionId.
+   * This guarantees 'sticky sessions' where the same user always gets the same A/B test variant.
+   */
+  assignVariant(experimentName, sessionId) {
+    const exp = this.experiments.get(experimentName);
+    if (!exp || exp.variants.length === 0) return null;
+    if (exp.variants.length === 1) return exp.variants[0].id;
+    const totalWeight = exp.variants.reduce((sum, v) => sum + v.weight, 0);
+    const hash = crypto2.createHash("md5").update(`${experimentName}_${sessionId}`).digest("hex");
+    const hashInt = parseInt(hash.slice(0, 8), 16);
+    const bucket = hashInt % totalWeight;
+    let cumulative = 0;
+    for (const variant of exp.variants) {
+      cumulative += variant.weight;
+      if (bucket < cumulative) {
+        return variant.id;
+      }
+    }
+    return exp.variants[0].id;
+  }
+  /** Retrieves the variant config object for an assigned variant id. */
+  getVariantConfig(experimentName, variantId) {
+    const exp = this.experiments.get(experimentName);
+    if (!exp) return null;
+    const v = exp.variants.find((v2) => v2.id === variantId);
+    return v ? v.config : null;
+  }
+};
+
 // src/widget/bot.ts
 var CustomerSupportBot = class {
   executor;
   connector;
   knowledgeBase;
   analytics;
+  outcomeTracker;
+  sessionStore;
   handoff;
+  piiRedactor;
+  experimentManager;
   greeting;
+  defaultSystemPrompt;
   middlewares = [];
   constructor(config) {
-    this.analytics = new ConversationAnalytics();
+    this.outcomeTracker = new OutcomeTracker();
+    this.analytics = new ConversationAnalytics(this.outcomeTracker);
+    this.sessionStore = config.sessionStore || new MemorySessionStore();
     if (config.knowledgeBase) {
       this.knowledgeBase = new KnowledgeBase(config.knowledgeBase);
     }
     if (config.handoff) {
       this.handoff = new HandoffManager(config.handoff);
     }
+    if (config.enablePIIRedaction) {
+      this.piiRedactor = new PIIRedactor();
+    }
+    if (config.experiments && config.experiments.length > 0) {
+      this.experimentManager = new ExperimentManager(config.experiments);
+    }
     const tools = [];
     if (config.apiConnector) {
       this.connector = new APIConnector(config.apiConnector);
@@ -13549,11 +13790,12 @@ Your role:
 - If you can't find an answer, politely suggest contacting human support
 - Always maintain a warm, professional tone
 - Never make up data \u2014 always verify through the API or context when available`;
+    this.defaultSystemPrompt = config.systemPrompt || defaultSystemPrompt;
     this.executor = new AgentExecutor({
       gateway: config.gateway,
       memory: config.memory || new InMemoryStore(100),
       tools,
-      systemPrompt: config.systemPrompt || defaultSystemPrompt,
+      systemPrompt: this.defaultSystemPrompt,
       telemetry: config.telemetry
     });
     this.greeting = config.greeting || `Hello! \u{1F44B} Welcome to ${config.companyName}. How can I help you today?`;
@@ -13562,17 +13804,34 @@ Your role:
   use(middleware) {
     this.middlewares.push(middleware);
   }
+  /** Record a business outcome for ROI tracking. */
+  trackOutcome(sessionId, type, valueUsd = 0, metadata) {
+    this.outcomeTracker.record(sessionId, type, valueUsd, metadata);
+  }
   /** Process a customer message and return the bot's response. */
   async chat(sessionId, message) {
-    this.analytics.startConversation(sessionId);
-    this.analytics.recordQuery(sessionId, message);
+    const activeMessage = this.piiRedactor ? this.piiRedactor.redact(message) : message;
+    let variantId;
+    if (this.experimentManager) {
+      variantId = this.experimentManager.assignVariant("default_experiment", sessionId) || void 0;
+      if (variantId) {
+        const config = this.experimentManager.getVariantConfig("default_experiment", variantId);
+        if (config && config.systemPrompt) {
+          this.executor.systemPrompt = config.systemPrompt;
+        } else {
+          this.executor.systemPrompt = this.defaultSystemPrompt;
+        }
+      }
+    }
+    this.analytics.startConversation(sessionId, "gpt-4o-mini", variantId);
+    this.analytics.recordQuery(sessionId, activeMessage);
     const startTime = Date.now();
     for (const mw of this.middlewares) {
-      const result2 = await mw({ sessionId, message, bot: this });
+      const result2 = await mw({ sessionId, message: activeMessage, bot: this });
       if (typeof result2 === "string") return result2;
     }
     if (this.handoff) {
-      const trigger = this.handoff.shouldEscalate(sessionId, message);
+      const trigger = this.handoff.shouldEscalate(sessionId, activeMessage);
       if (trigger) {
         const history = await this.executor.memory.getMessages(sessionId);
         let summary = "Customer needs assistance.";
@@ -13580,32 +13839,34 @@ Your role:
           summary = await this.executor.gateway.chat([
             { role: "system", content: "Summarize the customer's problem in one concise sentence for a human support agent context." },
             ...history,
-            { role: "user", content: message }
+            { role: "user", content: activeMessage }
           ]);
         } catch {
         }
-        const reply = await this.handoff.escalate(sessionId, trigger, history, message, summary);
+        const reply = await this.handoff.escalate(sessionId, trigger, history, activeMessage, summary);
         this.analytics.markHandedOff(sessionId);
         return reply;
       }
     }
-    let enhancedMessage = message;
+    let enhancedMessage = activeMessage;
     if (this.knowledgeBase) {
-      const context = await this.knowledgeBase.query(message);
+      const context = await this.knowledgeBase.query(activeMessage);
       if (context) {
         enhancedMessage = `Context from Knowledge Base:
 ${context}
 
-User Question: ${message}`;
+User Question: ${activeMessage}`;
       }
     }
     try {
       const reply = await this.executor.execute(sessionId, enhancedMessage, 8);
       this.analytics.recordResponse(sessionId, reply, Date.now() - startTime);
+      const history = await this.executor.getMemory().getMessages(sessionId);
+      await this.sessionStore.set(sessionId, { history, lastUpdated: Date.now() });
       return reply;
     } catch (e) {
       if (this.handoff) {
-        return this.handoff.escalate(sessionId, "low_confidence", [], message, `Error: ${e.message}`);
+        return this.handoff.escalate(sessionId, "low_confidence", [], activeMessage, `Error: ${e.message}`);
       }
       throw e;
     }
@@ -13809,6 +14070,87 @@ async function startChatServer(config) {
     console.log(`   GET  /health \u2014 Health check`);
   });
 }
+
+// src/channels/base.ts
+var ChannelAdapter = class {
+  bot;
+  constructor(config) {
+    this.bot = config.bot;
+  }
+  /** 
+   * Normalize incoming messages from different platforms 
+   * and route them to the core bot brain.
+   */
+  async handleMessage(sessionId, text) {
+    return this.bot.chat(sessionId, text);
+  }
+};
+
+// src/channels/slack.ts
+var SlackAdapter = class extends ChannelAdapter {
+  constructor(config) {
+    super(config);
+  }
+  async start() {
+    console.log("[SlackAdapter] Initializing Slack connection...");
+  }
+  async stop() {
+  }
+  /** Handler for Slack events (to be used by Express middleware). */
+  async handleEvent(event) {
+    if (event.type === "message" && !event.bot_id && event.text) {
+      const sessionId = `slack_${event.channel}_${event.user}`;
+      const reply = await this.handleMessage(sessionId, event.text);
+    }
+  }
+};
+
+// src/channels/telegram.ts
+var TelegramAdapter = class extends ChannelAdapter {
+  token;
+  polling = false;
+  offset = 0;
+  constructor(config) {
+    super(config);
+    this.token = config.token;
+  }
+  async start() {
+    this.polling = true;
+    this.runPollingLoop();
+    console.log("[TelegramAdapter] Started polling for updates...");
+  }
+  async stop() {
+    this.polling = false;
+  }
+  async runPollingLoop() {
+    while (this.polling) {
+      try {
+        const response = await fetch(`https://api.telegram.org/bot${this.token}/getUpdates?offset=${this.offset}&timeout=30`);
+        const data = await response.json();
+        if (data.ok && data.result && data.result.length > 0) {
+          for (const update of data.result) {
+            this.offset = update.update_id + 1;
+            if (update.message?.text) {
+              const chatId = update.message.chat.id.toString();
+              const reply = await this.handleMessage(`tg_${chatId}`, update.message.text);
+              await this.sendMessage(chatId, reply);
+            }
+          }
+        }
+      } catch (e) {
+        console.error(`[TelegramAdapter] Error: ${e.message}`);
+        await new Promise((r) => setTimeout(r, 5e3));
+      }
+    }
+  }
+  async sendMessage(chatId, text) {
+    await fetch(`https://api.telegram.org/bot${this.token}/sendMessage`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ chat_id: chatId, text })
+    });
+  }
+};
 export {
   AIModelGateway,
   APIConnector,
@@ -13821,6 +14163,7 @@ export {
   BaseSpeakerRecognizer,
   BaseTTSProvider,
   CachedGateway,
+  ChannelAdapter,
   ChatAgent,
   ChatMessageSchema,
   ChatRequestSchema,
@@ -13829,21 +14172,29 @@ export {
   ConfigurationError,
   ConversationAnalytics,
   CustomerSupportBot,
+  DEFAULT_REDACTION_RULES,
   EchoAI,
   EchoVoice,
+  ExperimentManager,
+  FileSessionStore,
   GatewayRoutingError,
   HandoffManager,
   InMemoryStore,
   KnowledgeBase,
+  MemorySessionStore,
   MemoryVectorStore,
   OPENAI_PRICING,
   OpenAITTS,
   OpenAIWhisperSTT,
+  OutcomeTracker,
+  PIIRedactor,
   PromptRegistry,
   PromptTemplate,
   PromptVersionError,
   ProviderDependencyError,
+  SlackAdapter,
   StructuredOutputError,
+  TelegramAdapter,
   ToolAgent,
   ToolExecutionError,
   UsageMetricsSchema,