@anuma/sdk 6.15.1 → 6.16.0

package/dist/telemetry/index.mjs

@@ -0,0 +1,226 @@
+// 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: () => {
+  }
+});
+export {
+  createMetricsHooks,
+  createRecallDiagnosticsHandler,
+  noopTelemetrySink
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@anuma/sdk",
-  "version": "6.15.1",
+  "version": "6.16.0",
   "description": "",
   "main": "./dist/index.cjs",
   "module": "./dist/index.mjs",
@@ -102,6 +102,12 @@
       "require": "./dist/utils/index.cjs",
       "default": "./dist/utils/index.cjs"
     },
+    "./telemetry": {
+      "types": "./dist/telemetry/index.d.ts",
+      "import": "./dist/telemetry/index.mjs",
+      "require": "./dist/telemetry/index.cjs",
+      "default": "./dist/telemetry/index.cjs"
+    },
     "./pii/transformers": {
       "types": "./dist/pii/transformers.d.ts",
       "import": "./dist/pii/transformers.mjs",