@farzanhossans/agentlens 0.2.0 → 0.2.1

package/dist/index.mjs

@@ -1,13 +1,10 @@
 import { randomUUID } from 'crypto';
 import { getCurrentTraceId, runWithTrace, getCurrentSpanId } from '@farzanhossans/agentlens-core';
 export { getCurrentSpanId, getCurrentTrace, getCurrentTraceId, runWithTrace } from '@farzanhossans/agentlens-core';
+import http from 'http';
+import https from 'https';
 
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
+// src/index.ts
 
 // src/registry.ts
 var LLM_REGISTRY = {
@@ -344,25 +341,40 @@ function patchFetch(transport2) {
   patched.__agentlens_patched = true;
   globalThis.fetch = patched;
 }
-
-// src/interceptors/https.ts
+var responseChunkRegistry = /* @__PURE__ */ new WeakMap();
+var incomingMessagePatched = false;
 function patchHttps(transport2) {
-  if (typeof process === "undefined" || typeof __require === "undefined") {
-    return;
-  }
-  try {
-    patchModule("https", transport2);
-    patchModule("http", transport2);
-  } catch {
-  }
+  patchIncomingMessage();
+  patchModule(http, "http", transport2);
+  patchModule(https, "https", transport2);
 }
-function patchModule(name, transport2) {
-  let mod;
-  try {
-    mod = __require(name);
-  } catch {
-    return;
-  }
+function patchIncomingMessage() {
+  if (incomingMessagePatched) return;
+  const IncomingMessage = http.IncomingMessage;
+  if (!IncomingMessage?.prototype) return;
+  const proto = IncomingMessage.prototype;
+  const originalPush = proto.push;
+  proto.push = function patchedPush(chunk, encoding) {
+    if (chunk !== null) {
+      const chunks = responseChunkRegistry.get(this);
+      if (chunks) {
+        try {
+          if (Buffer.isBuffer(chunk)) {
+            chunks.push(chunk);
+          } else if (typeof chunk === "string") {
+            chunks.push(Buffer.from(chunk, encoding ?? "utf8"));
+          } else if (chunk && typeof chunk === "object") {
+            chunks.push(Buffer.from(chunk));
+          }
+        } catch {
+        }
+      }
+    }
+    return originalPush.call(this, chunk, encoding);
+  };
+  incomingMessagePatched = true;
+}
+function patchModule(mod, name, transport2) {
   if (mod.__agentlens_patched) return;
   const original = mod.request.bind(mod);
   mod.request = function patchedRequest(...args) {
@@ -370,7 +382,6 @@ function patchModule(name, transport2) {
     if (!ctx) return original(...args);
     const start = Date.now();
     const requestChunks = [];
-    const responseChunks = [];
     const req = original(...args);
     const originalWrite = req.write.bind(req);
     req.write = function(chunk, ...rest) {
@@ -382,16 +393,12 @@ function patchModule(name, transport2) {
     };
     req.on("response", (...resArgs) => {
       const res = resArgs[0];
-      res.on("data", (chunk) => {
-        try {
-          responseChunks.push(toBuffer(chunk));
-        } catch {
-        }
-      });
+      const chunks = [];
+      responseChunkRegistry.set(res, chunks);
       res.on("end", () => {
         const latency = Date.now() - start;
         const requestText = Buffer.concat(requestChunks).toString("utf8");
-        const responseText = Buffer.concat(responseChunks).toString("utf8");
+        const responseText = Buffer.concat(chunks).toString("utf8");
         const requestBody = safeParse(requestText);
         const responseBody = safeParse(responseText);
         if (responseBody) {
@@ -405,6 +412,7 @@ function patchModule(name, transport2) {
             isStream: requestBody?.stream === true
           });
         }
+        responseChunkRegistry.delete(res);
       });
     });
     req.on("error", (...errArgs) => {
@@ -838,6 +846,7 @@ var Transport = class {
   constructor(config) {
     this.config = {
       apiKey: config.apiKey,
+      projectId: config.projectId,
       endpoint: config.endpoint,
       flushIntervalMs: config.flushIntervalMs ?? DEFAULT_FLUSH_INTERVAL_MS,
       maxBatchSize: config.maxBatchSize ?? DEFAULT_MAX_BATCH_SIZE,
@@ -848,6 +857,8 @@ var Transport = class {
     this.registerExitHandler();
   }
   push(payload) {
+    const startedAt = new Date(Date.now() - payload.latency).toISOString();
+    const endedAt = (/* @__PURE__ */ new Date()).toISOString();
     let parsed;
     try {
       parsed = parseSpan({
@@ -862,28 +873,34 @@ var Transport = class {
       }
       return;
     }
-    const outbound = this.toOutbound(parsed, payload.latency, payload.status);
+    const outbound = this.toOutbound(parsed, payload, startedAt, endedAt);
     this.enqueue(outbound);
   }
   pushError(payload) {
     const ids = this.resolveIds();
+    const startedAt = new Date(Date.now() - payload.latency).toISOString();
+    const endedAt = (/* @__PURE__ */ new Date()).toISOString();
     const span = {
       spanId: ids.spanId,
       traceId: ids.traceId,
       parentSpanId: ids.parentSpanId,
+      projectId: this.config.projectId,
+      name: `${payload.provider}.error`,
       model: "unknown",
       provider: payload.provider,
+      input: this.scrub(this.stringifyRequest(payload.request)),
+      output: "",
       inputTokens: 0,
       outputTokens: 0,
       totalTokens: 0,
       costUsd: 0,
-      inputText: this.scrub(this.stringifyRequest(payload.request)),
-      outputText: "",
-      isStream: false,
-      error: payload.error,
-      latency: payload.latency,
-      status: 0,
-      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      latencyMs: payload.latency,
+      status: "error",
+      errorMessage: payload.error,
+      metadata: { httpStatus: 0 },
+      startedAt,
+      endedAt,
+      isStream: false
     };
     this.enqueue(span);
   }
@@ -905,18 +922,30 @@ var Transport = class {
       this.timer = null;
     }
   }
-  toOutbound(parsed, latency, status) {
+  toOutbound(parsed, payload, startedAt, endedAt) {
     const ids = this.resolveIds();
+    const status = payload.status >= 200 && payload.status < 400 ? "success" : "error";
     return {
-      ...parsed,
       spanId: ids.spanId,
       traceId: ids.traceId,
       parentSpanId: ids.parentSpanId,
-      inputText: this.scrub(parsed.inputText),
-      outputText: this.scrub(parsed.outputText),
-      latency,
+      projectId: this.config.projectId,
+      name: spanNameFor(payload),
+      model: parsed.model,
+      provider: parsed.provider,
+      input: this.scrub(parsed.inputText),
+      output: this.scrub(parsed.outputText),
+      inputTokens: parsed.inputTokens,
+      outputTokens: parsed.outputTokens,
+      totalTokens: parsed.totalTokens,
+      costUsd: parsed.costUsd,
+      latencyMs: payload.latency,
       status,
-      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      errorMessage: parsed.error,
+      metadata: { httpStatus: payload.status },
+      startedAt,
+      endedAt,
+      isStream: parsed.isStream
     };
   }
   /**
@@ -955,12 +984,13 @@ var Transport = class {
   enqueue(span) {
     if (this.config.debug) {
       console.log("[agentlens] span", {
+        name: span.name,
         model: span.model,
         provider: span.provider,
         inputTokens: span.inputTokens,
         outputTokens: span.outputTokens,
         costUsd: span.costUsd,
-        latency: span.latency,
+        latencyMs: span.latencyMs,
         isStream: span.isStream
       });
     }
@@ -1021,6 +1051,9 @@ var Transport = class {
       method: "POST",
       headers: {
         "content-type": "application/json",
+        // Hosted ingest expects X-API-Key. Send Authorization too for any
+        // gateways that may sit in front (some Cloudflare workers want it).
+        "x-api-key": this.config.apiKey,
         authorization: `Bearer ${this.config.apiKey}`
       },
       body
@@ -1028,6 +1061,17 @@ var Transport = class {
     return { ok: res.ok, status: res.status };
   }
 };
+function spanNameFor(payload) {
+  const req = payload.request;
+  if (req && Array.isArray(req.messages)) return `${payload.provider}.chat`;
+  if (req && (typeof req.prompt === "string" || typeof req.input === "string")) {
+    return `${payload.provider}.completion`;
+  }
+  if (req && (req.input !== void 0 || req.contents !== void 0)) {
+    return `${payload.provider}.embedding`;
+  }
+  return `${payload.provider}.call`;
+}
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -1040,9 +1084,13 @@ var AgentLens = {
     if (!config?.apiKey) {
       throw new Error("AgentLens.init requires an apiKey");
     }
+    if (!config?.projectId) {
+      throw new Error("AgentLens.init requires a projectId");
+    }
     initialized = true;
     transport = new Transport({
       apiKey: config.apiKey,
+      projectId: config.projectId,
       endpoint: config.endpoint ?? DEFAULT_ENDPOINT,
       debug: config.debug ?? false,
       pii: config.pii ?? true,