@anuma/sdk 6.15.1 → 6.16.0

package/dist/telemetry/index.cjs

@@ -0,0 +1,255 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/telemetry/index.ts
+var index_exports = {};
+__export(index_exports, {
+  createMetricsHooks: () => createMetricsHooks,
+  createRecallDiagnosticsHandler: () => createRecallDiagnosticsHandler,
+  noopTelemetrySink: () => noopTelemetrySink
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/telemetry/metrics.ts
+var defaultNowMs = () => typeof performance !== "undefined" && typeof performance.now === "function" ? performance.now() : Date.now();
+function createMetricsHooks(sink, opts) {
+  const now = opts?.now ?? defaultNowMs;
+  const includeErrorMessages = opts?.includeErrorMessages ?? false;
+  const runs = /* @__PURE__ */ new Map();
+  const swallow = (call) => {
+    try {
+      const result = call();
+      if (result && typeof result.then === "function") {
+        void Promise.resolve(result).catch(() => {
+        });
+      }
+    } catch {
+    }
+  };
+  const track = (event, properties) => {
+    swallow(() => sink.track?.(event, properties));
+  };
+  const metric = (name, value, tags) => {
+    swallow(() => sink.metric?.(name, value, tags));
+  };
+  const errorProps = (error) => includeErrorMessages && error !== void 0 ? { error } : {};
+  const stateFor = (runId) => {
+    let state = runs.get(runId);
+    if (!state) {
+      state = { startedAt: now(), modelCalls: /* @__PURE__ */ new Map(), toolCalls: /* @__PURE__ */ new Map() };
+      runs.set(runId, state);
+    }
+    return state;
+  };
+  const finishRun = (runId) => {
+    runs.delete(runId);
+  };
+  return {
+    onRunStart: (e) => {
+      const state = stateFor(e.runId);
+      state.model = e.model;
+      state.startedAt = now();
+      track("run.started", { runId: e.runId, model: e.model });
+    },
+    onRunEnd: (e) => {
+      const state = stateFor(e.runId);
+      const durationMs = now() - state.startedAt;
+      track("run.completed", {
+        runId: e.runId,
+        totalSteps: e.totalSteps,
+        durationMs
+      });
+      metric("run.duration", durationMs, {
+        ...state.model ? { model: state.model } : {},
+        outcome: "completed"
+      });
+      finishRun(e.runId);
+    },
+    onRunError: (e) => {
+      const state = stateFor(e.runId);
+      const durationMs = now() - state.startedAt;
+      const errorType = e.errorObject?.name ?? "Error";
+      track("run.failed", {
+        runId: e.runId,
+        durationMs,
+        errorType,
+        ...errorProps(e.error),
+        stage: e.stage
+      });
+      metric("run.duration", durationMs, {
+        ...state.model ? { model: state.model } : {},
+        outcome: "failed"
+      });
+      finishRun(e.runId);
+    },
+    beforeModelCall: (e) => {
+      const state = stateFor(e.runId);
+      state.modelCalls.set(e.stepIndex, { startedAt: now(), model: e.model });
+    },
+    afterModelCall: (e) => {
+      const state = runs.get(e.runId);
+      const pending = state?.modelCalls.get(e.stepIndex);
+      state?.modelCalls.delete(e.stepIndex);
+      const latencyMs = pending ? now() - pending.startedAt : void 0;
+      const base = {
+        runId: e.runId,
+        stepIndex: e.stepIndex,
+        ...latencyMs !== void 0 ? { latencyMs } : {},
+        ...pending?.model ? { model: pending.model } : {}
+      };
+      if (e.error !== void 0) {
+        track("model.call.failed", { ...base, ...errorProps(e.error) });
+        if (latencyMs !== void 0) {
+          metric("model.call.latency", latencyMs, {
+            ...pending?.model ? { model: pending.model } : {},
+            outcome: "failed"
+          });
+        }
+        return;
+      }
+      track("model.call.completed", {
+        ...base,
+        ...e.usage?.inputTokens !== void 0 ? { inputTokens: e.usage.inputTokens } : {},
+        ...e.usage?.outputTokens !== void 0 ? { outputTokens: e.usage.outputTokens } : {},
+        ...e.finishReason !== void 0 ? { finishReason: e.finishReason } : {}
+      });
+      if (latencyMs !== void 0) {
+        metric("model.call.latency", latencyMs, {
+          ...pending?.model ? { model: pending.model } : {},
+          outcome: "completed"
+        });
+      }
+      if (e.usage?.inputTokens !== void 0) {
+        metric("model.call.tokens", e.usage.inputTokens, {
+          ...pending?.model ? { model: pending.model } : {},
+          direction: "input"
+        });
+      }
+      if (e.usage?.outputTokens !== void 0) {
+        metric("model.call.tokens", e.usage.outputTokens, {
+          ...pending?.model ? { model: pending.model } : {},
+          direction: "output"
+        });
+      }
+    },
+    beforeToolUse: (e) => {
+      const state = stateFor(e.runId);
+      state.toolCalls.set(e.toolCallId, { startedAt: now(), toolName: e.name });
+    },
+    afterToolUse: (e) => {
+      const state = runs.get(e.runId);
+      const pending = state?.toolCalls.get(e.toolCallId);
+      state?.toolCalls.delete(e.toolCallId);
+      const durationMs = pending ? now() - pending.startedAt : void 0;
+      const base = {
+        runId: e.runId,
+        stepIndex: e.stepIndex,
+        toolCallId: e.toolCallId,
+        toolName: e.name,
+        ...durationMs !== void 0 ? { durationMs } : {}
+      };
+      if (e.error !== void 0 || e.errorType !== void 0) {
+        track("tool.call.failed", {
+          ...base,
+          ...errorProps(e.error),
+          ...e.errorType !== void 0 ? { errorType: e.errorType } : {}
+        });
+        if (durationMs !== void 0) {
+          metric("tool.call.duration", durationMs, {
+            toolName: e.name,
+            outcome: "failed",
+            ...e.errorType !== void 0 ? { errorType: e.errorType } : {}
+          });
+        }
+        return;
+      }
+      track("tool.call.completed", base);
+      if (durationMs !== void 0) {
+        metric("tool.call.duration", durationMs, {
+          toolName: e.name,
+          outcome: "completed"
+        });
+      }
+    }
+  };
+}
+
+// src/telemetry/recall.ts
+function createRecallDiagnosticsHandler(sink) {
+  const swallow = (call) => {
+    try {
+      const result = call();
+      if (result && typeof result.then === "function") {
+        void Promise.resolve(result).catch(() => {
+        });
+      }
+    } catch {
+    }
+  };
+  const track = (event, properties) => {
+    swallow(() => sink.track?.(event, properties));
+  };
+  const metric = (name, value, tags) => {
+    swallow(() => sink.metric?.(name, value, tags));
+  };
+  return (diagnostics) => {
+    track("recall.completed", {
+      usedBudget: diagnostics.usedBudget,
+      reranked: diagnostics.reranked,
+      candidateCount: diagnostics.candidateCount,
+      factCount: diagnostics.factCount,
+      chunkCount: diagnostics.chunkCount,
+      totalMs: diagnostics.timings.total,
+      ...diagnostics.decryptLast !== void 0 ? { decryptLast: diagnostics.decryptLast } : {},
+      degradedCount: diagnostics.degraded.length
+    });
+    for (const reason of diagnostics.degraded) {
+      track("recall.degraded", { reason, usedBudget: diagnostics.usedBudget });
+    }
+    for (const [lane, ms] of Object.entries(diagnostics.timings)) {
+      metric("recall.duration", ms, { lane });
+    }
+    metric("recall.candidates", diagnostics.candidateCount, {});
+    metric("recall.facts", diagnostics.factCount, {});
+    metric("recall.chunks", diagnostics.chunkCount, {});
+    if (diagnostics.vaultSize !== void 0) {
+      metric("recall.vault.size", diagnostics.vaultSize, {});
+    }
+    if (diagnostics.vaultRowsDecrypted !== void 0) {
+      metric("recall.vault.rows_decrypted", diagnostics.vaultRowsDecrypted, {});
+    }
+    if (diagnostics.vaultRowsEmbedded !== void 0) {
+      metric("recall.vault.rows_embedded", diagnostics.vaultRowsEmbedded, {});
+    }
+  };
+}
+
+// src/telemetry/types.ts
+var noopTelemetrySink = Object.freeze({
+  track: () => {
+  },
+  metric: () => {
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createMetricsHooks,
+  createRecallDiagnosticsHandler,
+  noopTelemetrySink
+});