@burtson-labs/bandit-engine 2.0.58 → 2.0.60

package/dist/index.js

@@ -14862,7 +14862,11 @@ ${listMarkdown}`;
           href,
           target: "_blank",
           rel: "noopener noreferrer",
-          style: { color: theme.palette.primary.main, textDecoration: "underline" },
+          style: {
+            color: theme.palette.info?.main ?? theme.palette.primary.main,
+            textDecoration: "underline",
+            textUnderlineOffset: "2px"
+          },
           ...props,
           children
         }
@@ -19107,6 +19111,330 @@ ${sanitize(
   }
 });
 
+// src/services/telemetry/otlpExporter.ts
+function redactSecretsString(s) {
+  return s.replace(/\b(?:sk|tvly|ghp|gho|pk|rk)[-_][A-Za-z0-9]{8,}\b/gi, "[redacted]").replace(/\beyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+/g, "[redacted-jwt]").replace(/\bBearer\s+[A-Za-z0-9._-]{8,}/gi, "Bearer [redacted]");
+}
+function resolveTelemetryConfig(opts) {
+  if (!opts.telemetry?.enabled) return null;
+  const endpoint = (opts.telemetry.endpoint ?? "https://otlp.burtson.ai").replace(/\/+$/, "");
+  const headers = { ...opts.telemetry.headers ?? {} };
+  const hasAuth = Object.keys(headers).some((k) => k.toLowerCase() === "authorization");
+  if (!hasAuth && opts.banditApiKey) {
+    headers["Authorization"] = `Bearer ${opts.banditApiKey}`;
+  }
+  const mode = opts.telemetry.mode ?? "metrics+traces";
+  return { endpoint, headers, mode, serviceName: opts.telemetry.serviceName ?? "bandit-web" };
+}
+function toAttrs(rec) {
+  const out = [];
+  for (const [key, v] of Object.entries(rec)) {
+    if (v === void 0 || v === null || v === "") continue;
+    if (typeof v === "boolean") out.push({ key, value: { boolValue: v } });
+    else if (typeof v === "number")
+      out.push({ key, value: Number.isInteger(v) ? { intValue: String(v) } : { doubleValue: v } });
+    else out.push({ key, value: { stringValue: v } });
+  }
+  return out;
+}
+function hex(bytes) {
+  const arr = new Uint8Array(bytes);
+  if (webCrypto?.getRandomValues) webCrypto.getRandomValues(arr);
+  return Array.from(arr, (b) => b.toString(16).padStart(2, "0")).join("");
+}
+function histogramPoint(value, bounds, attrs, startMs, endMs) {
+  const counts = new Array(bounds.length + 1).fill(0);
+  let idx = bounds.findIndex((b) => value <= b);
+  if (idx === -1) idx = bounds.length;
+  counts[idx] = 1;
+  return {
+    attributes: toAttrs(attrs),
+    startTimeUnixNano: nano(startMs),
+    timeUnixNano: nano(endMs),
+    count: "1",
+    sum: value,
+    bucketCounts: counts.map(String),
+    explicitBounds: bounds
+  };
+}
+function sumPoint(value, attrs, startMs, endMs) {
+  return {
+    attributes: toAttrs(attrs),
+    startTimeUnixNano: nano(startMs),
+    timeUnixNano: nano(endMs),
+    asInt: String(Math.round(value))
+  };
+}
+var webCrypto, nano, TTFT_BUCKETS, DURATION_BUCKETS, clip, TelemetryExporter;
+var init_otlpExporter = __esm({
+  "src/services/telemetry/otlpExporter.ts"() {
+    "use strict";
+    init_debugLogger();
+    webCrypto = globalThis.crypto;
+    nano = (ms) => String(Math.round(ms * 1e6));
+    TTFT_BUCKETS = [0.1, 0.25, 0.5, 1, 2, 5, 10, 30];
+    DURATION_BUCKETS = [0.5, 1, 2, 5, 10, 30, 60, 120, 300];
+    clip = (s, n = 120) => redactSecretsString(s.slice(0, n)).slice(0, n);
+    TelemetryExporter = class {
+      cfg;
+      now;
+      traceId = "";
+      turn = null;
+      llm = null;
+      llmFirstChunkMs = 0;
+      openTools = [];
+      completedSpans = [];
+      model = "";
+      turnChunkChars = 0;
+      turnTokens = 0;
+      ttftSeconds = null;
+      constructor(cfg, opts) {
+        this.cfg = cfg;
+        this.now = opts?.now ?? (() => Date.now());
+      }
+      startTurn(goal, model) {
+        this.traceId = hex(16);
+        this.model = model;
+        this.turnChunkChars = 0;
+        this.turnTokens = 0;
+        this.ttftSeconds = null;
+        this.llm = null;
+        this.llmFirstChunkMs = 0;
+        this.openTools = [];
+        this.completedSpans = [];
+        this.turn = {
+          spanId: hex(8),
+          name: "agent.turn",
+          startMs: this.now(),
+          attrs: { "gen_ai.request.model": model, "bandit.turn.goal": clip(goal, 160) }
+        };
+      }
+      /** Fed from the chat turn lifecycle. Best-effort; swallows bad payloads. */
+      onEvent(type, payload) {
+        if (!this.turn) return;
+        try {
+          const p = payload ?? {};
+          switch (type) {
+            case "tool_loop:llm_start":
+              this.llm = {
+                spanId: hex(8),
+                parentSpanId: this.turn.spanId,
+                name: "llm.generate",
+                startMs: this.now(),
+                attrs: { "gen_ai.request.model": this.model }
+              };
+              this.llmFirstChunkMs = 0;
+              break;
+            case "tool_loop:llm_chunk": {
+              const chunk = typeof p.chunk === "string" ? p.chunk : "";
+              if (this.llm && this.llmFirstChunkMs === 0 && chunk.length > 0) {
+                this.llmFirstChunkMs = this.now();
+                const ttft = (this.llmFirstChunkMs - this.llm.startMs) / 1e3;
+                if (this.ttftSeconds === null) this.ttftSeconds = ttft;
+                this.llm.attrs["bandit.llm.ttft_seconds"] = ttft;
+              }
+              this.turnChunkChars += chunk.length;
+              this.turnTokens = Math.floor(this.turnChunkChars / 4);
+              break;
+            }
+            case "tool_loop:llm_response":
+              if (this.llm) {
+                this.llm.endMs = this.now();
+                if (typeof p.responseLength === "number") this.llm.attrs["bandit.llm.response_chars"] = p.responseLength;
+                this.completedSpans.push(this.llm);
+                this.llm = null;
+              }
+              break;
+            case "tool_loop:tool_execute": {
+              const name = typeof p.name === "string" ? p.name : "tool";
+              const params = p.params ?? {};
+              const primary = params.query ?? params.url ?? params.prompt ?? params.topic ?? "";
+              this.openTools.push({
+                spanId: hex(8),
+                parentSpanId: this.turn.spanId,
+                name: `tool.${name}`,
+                startMs: this.now(),
+                attrs: { "bandit.tool.name": name, "bandit.tool.primary": primary ? clip(primary) : void 0 }
+              });
+              break;
+            }
+            case "tool_loop:tool_result":
+            case "tool_loop:tool_error": {
+              const name = typeof p.name === "string" ? p.name : void 0;
+              const span = this.takeOpenTool(name);
+              if (span) {
+                span.endMs = this.now();
+                if (type === "tool_loop:tool_error" || p.isError === true) span.error = "tool error";
+                this.completedSpans.push(span);
+              }
+              break;
+            }
+          }
+        } catch {
+        }
+      }
+      takeOpenTool(name) {
+        if (name) {
+          for (let i = this.openTools.length - 1; i >= 0; i -= 1) {
+            if (this.openTools[i].name === `tool.${name}`) return this.openTools.splice(i, 1)[0];
+          }
+        }
+        return this.openTools.shift();
+      }
+      /** Close the turn, build OTLP traces + metrics, and flush. Never rejects. */
+      async endTurn(outcome) {
+        const turn = this.turn;
+        if (!turn) return;
+        this.turn = null;
+        const end = this.now();
+        if (this.llm && !this.llm.endMs) {
+          this.llm.endMs = end;
+          this.completedSpans.push(this.llm);
+          this.llm = null;
+        }
+        for (const t of this.openTools.splice(0)) {
+          t.endMs = end;
+          t.error = t.error ?? "incomplete";
+          this.completedSpans.push(t);
+        }
+        turn.endMs = end;
+        if (outcome?.error) turn.error = outcome.error;
+        const traceId = this.traceId;
+        const spans = [turn, ...this.completedSpans];
+        const jobs = [];
+        if (this.cfg.mode === "metrics+traces") jobs.push(this.post("/v1/traces", this.buildTraces(traceId, spans)));
+        jobs.push(this.post("/v1/metrics", this.buildMetrics(turn)));
+        try {
+          await Promise.all(jobs);
+        } catch {
+        }
+      }
+      buildTraces(traceId, spans) {
+        return {
+          resourceSpans: [
+            {
+              resource: { attributes: toAttrs({ "service.name": this.cfg.serviceName }) },
+              scopeSpans: [
+                {
+                  scope: { name: this.cfg.serviceName },
+                  spans: spans.map((s) => ({
+                    traceId,
+                    spanId: s.spanId,
+                    parentSpanId: s.parentSpanId,
+                    name: s.name,
+                    kind: 1,
+                    startTimeUnixNano: nano(s.startMs),
+                    endTimeUnixNano: nano(s.endMs ?? s.startMs),
+                    attributes: toAttrs(s.attrs),
+                    status: s.error ? { code: 2, message: s.error.slice(0, 200) } : { code: 1 }
+                  }))
+                }
+              ]
+            }
+          ]
+        };
+      }
+      buildMetrics(turn) {
+        const start = turn.startMs;
+        const end = turn.endMs ?? this.now();
+        const metrics = [];
+        if (this.turnTokens > 0) {
+          metrics.push({
+            name: "bandit.llm.tokens",
+            sum: {
+              aggregationTemporality: 1,
+              isMonotonic: true,
+              dataPoints: [sumPoint(this.turnTokens, { type: "output", "gen_ai.request.model": this.model }, start, end)]
+            }
+          });
+        }
+        if (this.ttftSeconds !== null) {
+          metrics.push({
+            name: "bandit.llm.ttft",
+            unit: "s",
+            histogram: {
+              aggregationTemporality: 1,
+              dataPoints: [histogramPoint(this.ttftSeconds, TTFT_BUCKETS, { "gen_ai.request.model": this.model }, start, end)]
+            }
+          });
+        }
+        metrics.push({
+          name: "bandit.turn.duration",
+          unit: "s",
+          histogram: {
+            aggregationTemporality: 1,
+            dataPoints: [histogramPoint((end - start) / 1e3, DURATION_BUCKETS, { "gen_ai.request.model": this.model }, start, end)]
+          }
+        });
+        return {
+          resourceMetrics: [
+            {
+              resource: { attributes: toAttrs({ "service.name": this.cfg.serviceName }) },
+              scopeMetrics: [{ scope: { name: this.cfg.serviceName }, metrics }]
+            }
+          ]
+        };
+      }
+      async post(path, body) {
+        const doFetch = globalThis.fetch;
+        if (!doFetch) return;
+        const ctrl = new AbortController();
+        const timer = setTimeout(() => ctrl.abort(), 4e3);
+        try {
+          await doFetch(`${this.cfg.endpoint}${path}`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json", ...this.cfg.headers },
+            body: JSON.stringify(body),
+            signal: ctrl.signal
+          });
+        } catch (e) {
+          debugLogger.debug("[telemetry] OTLP post failed", {
+            path,
+            error: e instanceof Error ? e.message : String(e)
+          });
+        } finally {
+          clearTimeout(timer);
+        }
+      }
+    };
+  }
+});
+
+// src/services/telemetry/index.ts
+function syncTelemetry() {
+  try {
+    const settings = usePackageSettingsStore.getState().settings;
+    const cfg = resolveTelemetryConfig({
+      telemetry: settings?.telemetry,
+      banditApiKey: authenticationService.getToken() ?? void 0
+    });
+    active = cfg ? new TelemetryExporter(cfg) : null;
+  } catch {
+    active = null;
+  }
+  return active !== null;
+}
+function telemetryStartTurn(goal, model) {
+  active?.startTurn(goal, model);
+}
+function telemetryEvent(type, payload) {
+  active?.onEvent(type, payload);
+}
+function telemetryEndTurn(outcome) {
+  void active?.endTurn(outcome);
+}
+var active;
+var init_telemetry = __esm({
+  "src/services/telemetry/index.ts"() {
+    "use strict";
+    init_otlpExporter();
+    init_packageSettingsStore();
+    init_authenticationService();
+    init_otlpExporter();
+    active = null;
+  }
+});
+
 // src/chat/hooks/useMemoryEnhancer.tsx
 var import_rxjs20, MEMORY_LIMIT, MIN_MEMORY_WORDS, MERGE_THRESHOLD, REJECT_ECHO_THRESHOLD, REJECT_DUPLICATE_THRESHOLD, CONTEXTUAL_DIVERGENCE_THRESHOLD, normalizeText, isStructurallyDuplicate, isAboutBandit, hasEngagementValue, isMemoryTooShortOrGeneric, isPersonalText, mergeMemory, isVoiceShifted, sanitizeMemory, sanitizeMemoryText, shouldAcceptMemory, isContextuallyDivergent, useMemoryEnhancer;
 var init_useMemoryEnhancer = __esm({
@@ -19770,7 +20098,14 @@ var init_mcpService = __esm({
             requestOptions.body = JSON.stringify(toolCall.parameters);
           }
         }
-        const response = await fetch(url, requestOptions);
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), 3e4);
+        let response;
+        try {
+          response = await fetch(url, { ...requestOptions, signal: controller.signal });
+        } finally {
+          clearTimeout(timeoutId);
+        }
         const data = await response.json();
         if (!response.ok) {
           debugLogger.error("MCP tool execution failed", {
@@ -19841,6 +20176,7 @@ var init_useAIProvider = __esm({
     import_react22 = require("react");
     init_knowledgeStore();
     init_aiProviderStore();
+    init_telemetry();
     init_conversationStore();
     init_useMemoryEnhancer();
     init_useVectorStore();
@@ -20605,6 +20941,9 @@ ${protocol}`;
               setStreamBuffer(latestDisplayMessage);
             }, delay);
           };
+          syncTelemetry();
+          telemetryStartTurn(question, modelName);
+          telemetryEvent("tool_loop:llm_start");
           const stream = provider.chat(request);
           const initialPlaceholderQuestion = lastEntry?.question;
           lastPartialRef.current = { text: "", images: [...imageList], usedDocs, question };
@@ -20618,7 +20957,10 @@ ${protocol}`;
           const sub = stream.subscribe({
             next: (data) => {
               if (!data?.message?.content && !data?.message?.tool_calls) return;
-              if (data.message.content) fullMessage += data.message.content;
+              if (data.message.content) {
+                fullMessage += data.message.content;
+                telemetryEvent("tool_loop:llm_chunk", { chunk: data.message.content });
+              }
               const inThinkBlock = /<think>/.test(fullMessage) && !/<think>[\s\S]*<\/think>/.test(fullMessage);
               setIsThinking?.(inThinkBlock);
               const visibleMessage = stripThinking(fullMessage);
@@ -20650,6 +20992,7 @@ ${protocol}`;
               setIsThinking?.(false);
               setPendingMessage(null);
               setLogoVisible(false);
+              telemetryEndTurn({ error: err?.message || "stream error" });
               if (onError) {
                 onError(err);
               }
@@ -20657,6 +21000,7 @@ ${protocol}`;
             complete: async () => {
               try {
                 setIsThinking?.(false);
+                telemetryEvent("tool_loop:llm_response", { responseLength: fullMessage.length });
                 latestDisplayMessage = stripThinking(fullMessage);
                 if (!sawToolBlock) {
                   flushNow();
@@ -20665,6 +21009,7 @@ ${protocol}`;
                 let enhancedMessage = fullMessage;
                 const summarizableResults = [];
                 const inlineImageBlocks = [];
+                const collectedSources = [];
                 if (toolCallMatches && toolCallMatches.length > 0 && mcpToolsAvailable) {
                   debugLogger.info("Detected tool calls in AI response", {
                     toolCallCount: toolCallMatches.length,
@@ -20699,10 +21044,21 @@ ${protocol}`;
                       });
                       const placeholderToken = `<<TOOL_LOADING_${functionName}_${Math.random().toString(36).slice(2)}>>`;
                       enhancedMessage = enhancedMessage.replace(match, placeholderToken);
+                      clearFlushTimer();
+                      const toolStatus = functionName === "web_search" || functionName === "web-search" ? "Searching the web\u2026" : functionName === "web_fetch" || functionName === "web-fetch" ? "Reading the page\u2026" : functionName === "image_generation" || functionName === "image-generation" ? "Generating the image\u2026" : "Working on it\u2026";
+                      const toolPreamble = stripToolBlocks(fullMessage).trim();
+                      setStreamBuffer(toolPreamble ? `${toolPreamble}
+
+_${toolStatus}_` : `_${toolStatus}_`);
+                      telemetryEvent("tool_loop:tool_execute", { name: functionName, params: parsedParams });
                       const result = await executeMCPTool({
                         toolName: functionName,
                         parameters: parsedParams
                       });
+                      telemetryEvent(result.success ? "tool_loop:tool_result" : "tool_loop:tool_error", {
+                        name: functionName,
+                        isError: !result.success
+                      });
                       let resultText = "";
                       if (result.success) {
                         if (functionName === "web_search" || functionName === "web-search") {
@@ -20716,18 +21072,16 @@ ${protocol}`;
                             blocks.push(
                               items.slice(0, 6).map((item, index) => {
                                 const title = item.title?.trim() || "Untitled";
-                                const url = item.url?.trim();
+                                const url = item.url?.trim() || "";
                                 const snippet = item.content?.trim();
-                                let line = `${index + 1}. **${title}**`;
-                                if (url) line += `
-   ${url}`;
+                                if (url) collectedSources.push({ title, url });
+                                let line = url ? `${index + 1}. [${title}](${url})` : `${index + 1}. ${title}`;
                                 if (snippet) {
                                   const truncated = snippet.length > 300 ? `${snippet.slice(0, 300)}\u2026` : snippet;
-                                  line += `
-   ${truncated}`;
+                                  line += ` \u2014 ${truncated}`;
                                 }
                                 return line;
-                              }).join("\n\n")
+                              }).join("\n")
                             );
                           }
                           resultText = blocks.length ? blocks.join("\n\n") : `No results found${search.query ? ` for "${search.query}"` : ""}.`;
@@ -20809,7 +21163,7 @@ ${r.output}`).join("\n\n");
 
 ${toolResultsText}
 
-Using these results together with your own knowledge, answer my original question concisely and in a natural, well-formatted way. Cite source URLs inline when you rely on them. Do NOT output tool_code or call any tools again.`
+Using these results together with your own knowledge, answer my original question concisely and in a natural, well-formatted way. Reference sources by name where relevant, but do NOT paste raw URLs or a list of links \u2014 a clean Sources section is added automatically below your answer. Do NOT output tool_code or call any tools again.`
                         }
                       ];
                       const summaryRequest = {
@@ -20819,9 +21173,22 @@ Using these results together with your own knowledge, answer my original questio
                         options: { num_predict: tokenLimit + 250 }
                       };
                       clearFlushTimer();
-                      setStreamBuffer("");
+                      const summaryPreamble = stripToolBlocks(fullMessage).trim();
+                      setStreamBuffer(
+                        summaryPreamble ? `${summaryPreamble}
+
+_Writing the answer\u2026_` : "_Writing the answer\u2026_"
+                      );
                       const summaryText = await new Promise((resolve) => {
                         let acc = "";
+                        let settled = false;
+                        let timer;
+                        const done = (value) => {
+                          if (settled) return;
+                          settled = true;
+                          if (timer) clearTimeout(timer);
+                          resolve(value);
+                        };
                         const summarySub = provider.chat(summaryRequest).subscribe({
                           next: (data) => {
                             if (data?.message?.content) {
@@ -20836,14 +21203,33 @@ Using these results together with your own knowledge, answer my original questio
                             debugLogger.error("Summarization pass failed", {
                               error: summaryErr instanceof Error ? summaryErr.message : String(summaryErr)
                             });
-                            resolve("");
+                            done("");
                           },
-                          complete: () => resolve(stripThinking(acc).trim())
+                          complete: () => done(stripThinking(acc).trim())
                         });
                         currentSubRef.current = summarySub;
+                        timer = setTimeout(() => {
+                          debugLogger.warn("Summarization pass timed out; using inline tool output");
+                          try {
+                            summarySub.unsubscribe();
+                          } catch {
+                          }
+                          done("");
+                        }, 3e4);
                       });
                       if (summaryText.trim()) {
-                        enhancedMessage = summaryText + (inlineImageBlocks.length ? `
+                        const sourcesMd = collectedSources.length ? `
+
+**Sources**
+${collectedSources.slice(0, 6).map((s) => {
+                          let domain = s.url;
+                          try {
+                            domain = new URL(s.url).hostname.replace(/^www\./, "");
+                          } catch {
+                          }
+                          return `- [${s.title || domain}](${s.url}) \u2014 ${domain}`;
+                        }).join("\n")}` : "";
+                        enhancedMessage = summaryText + sourcesMd + (inlineImageBlocks.length ? `
 
 ${inlineImageBlocks.join("\n\n")}` : "");
                       }
@@ -20892,6 +21278,7 @@ ${inlineImageBlocks.join("\n\n")}` : "");
                 }
                 setInputValue("");
                 setPastedImages([]);
+                telemetryEndTurn();
                 setTimeout(() => {
                   clearFlushTimer();
                   setPendingMessage(null);
@@ -20907,6 +21294,7 @@ ${inlineImageBlocks.join("\n\n")}` : "");
                 overrideComponentStatus("Idle");
                 setIsSubmitting(false);
                 setIsStreaming(false);
+                telemetryEndTurn({ error: e instanceof Error ? e.message : String(e) });
               }
             }
           });
@@ -23765,10 +24153,10 @@ var init_enhanced_mobile_conversations_modal = __esm({
       (0, import_react30.useEffect)(() => {
         setDeletedConversationIds((prev) => {
           let changed = false;
-          const active = new Set(conversations.map((conv) => conv.id));
+          const active2 = new Set(conversations.map((conv) => conv.id));
           const next = /* @__PURE__ */ new Set();
           prev.forEach((id) => {
-            if (active.has(id)) {
+            if (active2.has(id)) {
               next.add(id);
             } else {
               changed = true;