@farzanhossans/agentlens 0.2.0 → 0.2.1

package/dist/index.d.mts

@@ -1,6 +1,7 @@
 export { getCurrentSpanId, getCurrentTrace, getCurrentTraceId, runWithTrace } from '@farzanhossans/agentlens-core';
 
 type ParserName = 'openai' | 'anthropic' | 'gemini' | 'cohere' | 'mistral';
+type SpanStatus = 'success' | 'error' | 'timeout';
 interface LLMEndpoint {
     provider: string;
     parser: ParserName;
@@ -20,19 +21,46 @@ interface ParsedSpan {
 }
 interface AgentLensConfig {
     apiKey: string;
+    /**
+     * Project UUID. Required by the AgentLens ingest contract — every span
+     * carries this so the server can route to the right project.
+     */
+    projectId: string;
     endpoint?: string;
     debug?: boolean;
     pii?: boolean;
     flushIntervalMs?: number;
     maxBatchSize?: number;
 }
-interface OutboundSpan extends ParsedSpan {
+/**
+ * Wire-format span sent to the AgentLens ingest endpoint. Matches the
+ * server-side Zod schema used by both the API controller and the
+ * Cloudflare ingest worker.
+ */
+interface OutboundSpan {
     spanId: string;
     traceId: string;
     parentSpanId?: string;
-    timestamp: string;
-    latency: number;
-    status: number;
+    projectId: string;
+    /** Human-friendly span name (e.g. "openai.chat", "anthropic.messages"). */
+    name: string;
+    model: string;
+    provider: string;
+    /** Raw LLM prompt text (PII-scrubbed if pii=true). */
+    input: string;
+    /** Raw LLM completion text (PII-scrubbed if pii=true). */
+    output: string;
+    inputTokens: number;
+    outputTokens: number;
+    totalTokens: number;
+    costUsd: number;
+    latencyMs: number;
+    status: SpanStatus;
+    errorMessage?: string;
+    metadata: Record<string, unknown>;
+    startedAt: string;
+    endedAt: string;
+    isStream: boolean;
 }
 
 declare const LLM_REGISTRY: Record<string, LLMEndpoint>;

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 export { getCurrentSpanId, getCurrentTrace, getCurrentTraceId, runWithTrace } from '@farzanhossans/agentlens-core';
 
 type ParserName = 'openai' | 'anthropic' | 'gemini' | 'cohere' | 'mistral';
+type SpanStatus = 'success' | 'error' | 'timeout';
 interface LLMEndpoint {
     provider: string;
     parser: ParserName;
@@ -20,19 +21,46 @@ interface ParsedSpan {
 }
 interface AgentLensConfig {
     apiKey: string;
+    /**
+     * Project UUID. Required by the AgentLens ingest contract — every span
+     * carries this so the server can route to the right project.
+     */
+    projectId: string;
     endpoint?: string;
     debug?: boolean;
     pii?: boolean;
     flushIntervalMs?: number;
     maxBatchSize?: number;
 }
-interface OutboundSpan extends ParsedSpan {
+/**
+ * Wire-format span sent to the AgentLens ingest endpoint. Matches the
+ * server-side Zod schema used by both the API controller and the
+ * Cloudflare ingest worker.
+ */
+interface OutboundSpan {
     spanId: string;
     traceId: string;
     parentSpanId?: string;
-    timestamp: string;
-    latency: number;
-    status: number;
+    projectId: string;
+    /** Human-friendly span name (e.g. "openai.chat", "anthropic.messages"). */
+    name: string;
+    model: string;
+    provider: string;
+    /** Raw LLM prompt text (PII-scrubbed if pii=true). */
+    input: string;
+    /** Raw LLM completion text (PII-scrubbed if pii=true). */
+    output: string;
+    inputTokens: number;
+    outputTokens: number;
+    totalTokens: number;
+    costUsd: number;
+    latencyMs: number;
+    status: SpanStatus;
+    errorMessage?: string;
+    metadata: Record<string, unknown>;
+    startedAt: string;
+    endedAt: string;
+    isStream: boolean;
 }
 
 declare const LLM_REGISTRY: Record<string, LLMEndpoint>;

package/dist/index.js

@@ -2,13 +2,15 @@
 
 var crypto = require('crypto');
 var agentlensCore = require('@farzanhossans/agentlens-core');
+var http = require('http');
+var https = require('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');
-});
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var http__default = /*#__PURE__*/_interopDefault(http);
+var https__default = /*#__PURE__*/_interopDefault(https);
+
+// src/index.ts
 
 // src/registry.ts
 var LLM_REGISTRY = {
@@ -345,25 +347,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__default.default, "http", transport2);
+  patchModule(https__default.default, "https", transport2);
 }
-function patchModule(name, transport2) {
-  let mod;
-  try {
-    mod = __require(name);
-  } catch {
-    return;
-  }
+function patchIncomingMessage() {
+  if (incomingMessagePatched) return;
+  const IncomingMessage = http__default.default.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) {
@@ -371,7 +388,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) {
@@ -383,16 +399,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) {
@@ -406,6 +418,7 @@ function patchModule(name, transport2) {
             isStream: requestBody?.stream === true
           });
         }
+        responseChunkRegistry.delete(res);
       });
     });
     req.on("error", (...errArgs) => {
@@ -839,6 +852,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,
@@ -849,6 +863,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({
@@ -863,28 +879,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);
   }
@@ -906,18 +928,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
     };
   }
   /**
@@ -956,12 +990,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
       });
     }
@@ -1022,6 +1057,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
@@ -1029,6 +1067,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));
 }
@@ -1041,9 +1090,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,