@burtson-labs/bandit-engine 2.0.58 → 2.0.60

package/dist/{chunk-N7GCS2BH.mjs → chunk-MFDMM5MS.mjs}

@@ -3,10 +3,10 @@ import {
 } from "./chunk-ONQMRE2G.mjs";
 import {
   StreamingMarkdown_default
-} from "./chunk-KM7FUWCM.mjs";
+} from "./chunk-SRCCNBHF.mjs";
 import {
   useMCPToolsStore
-} from "./chunk-QPBG6JQE.mjs";
+} from "./chunk-6QTTNYF2.mjs";
 import {
   AddIcon,
   ArrowDownwardIcon,
@@ -42,7 +42,7 @@ import {
   useNotificationService,
   useTTS,
   useVoiceStore
-} from "./chunk-KNBWR4DS.mjs";
+} from "./chunk-5WQMMCZQ.mjs";
 import {
   authenticationService,
   brandingService_default,
@@ -67,13 +67,13 @@ import {
   useMemoryStore,
   useProjectStore,
   useVectorStore
-} from "./chunk-557E5VZ2.mjs";
+} from "./chunk-EUBVBTB3.mjs";
 import {
   indexedDBService_default,
   useModelStore,
   usePackageSettingsStore,
   usePreferencesStore
-} from "./chunk-7ZDS33S2.mjs";
+} from "./chunk-IPMTNREZ.mjs";
 import {
   useAIProviderStore
 } from "./chunk-H3BYFEIE.mjs";
@@ -1388,6 +1388,313 @@ var chat_input_default = ChatInput;
 // src/chat/hooks/useAIProvider.tsx
 import { useCallback, useRef as useRef3 } from "react";
 
+// 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;
+}
+var webCrypto = globalThis.crypto;
+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("");
+}
+var nano = (ms) => String(Math.round(ms * 1e6));
+var TTFT_BUCKETS = [0.1, 0.25, 0.5, 1, 2, 5, 10, 30];
+var DURATION_BUCKETS = [0.5, 1, 2, 5, 10, 30, 60, 120, 300];
+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 clip = (s, n = 120) => redactSecretsString(s.slice(0, n)).slice(0, n);
+var 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
+var active = null;
+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);
+}
+
 // src/chat/hooks/useMemoryEnhancer.tsx
 import { lastValueFrom, map as map2 } from "rxjs";
 var MEMORY_LIMIT = 100;
@@ -2021,7 +2328,14 @@ var executeMCPTool = async (toolCall) => {
         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", {
@@ -2828,6 +3142,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 };
@@ -2841,7 +3158,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);
@@ -2873,6 +3193,7 @@ ${protocol}`;
           setIsThinking?.(false);
           setPendingMessage(null);
           setLogoVisible(false);
+          telemetryEndTurn({ error: err?.message || "stream error" });
           if (onError) {
             onError(err);
           }
@@ -2880,6 +3201,7 @@ ${protocol}`;
         complete: async () => {
           try {
             setIsThinking?.(false);
+            telemetryEvent("tool_loop:llm_response", { responseLength: fullMessage.length });
             latestDisplayMessage = stripThinking(fullMessage);
             if (!sawToolBlock) {
               flushNow();
@@ -2888,6 +3210,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,
@@ -2922,10 +3245,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") {
@@ -2939,18 +3273,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}"` : ""}.`;
@@ -3032,7 +3364,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 = {
@@ -3042,9 +3374,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) {
@@ -3059,14 +3404,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")}` : "");
                   }
@@ -3115,6 +3479,7 @@ ${inlineImageBlocks.join("\n\n")}` : "");
             }
             setInputValue("");
             setPastedImages([]);
+            telemetryEndTurn();
             setTimeout(() => {
               clearFlushTimer();
               setPendingMessage(null);
@@ -3130,6 +3495,7 @@ ${inlineImageBlocks.join("\n\n")}` : "");
             overrideComponentStatus("Idle");
             setIsSubmitting(false);
             setIsStreaming(false);
+            telemetryEndTurn({ error: e instanceof Error ? e.message : String(e) });
           }
         }
       });
@@ -6031,10 +6397,10 @@ var EnhancedMobileConversationsModal = ({
   useEffect10(() => {
     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;
@@ -9220,4 +9586,4 @@ var chat_default = Chat;
 export {
   chat_default
 };
-//# sourceMappingURL=chunk-N7GCS2BH.mjs.map
+//# sourceMappingURL=chunk-MFDMM5MS.mjs.map