@farzanhossans/agentlens 0.2.0

package/dist/index.js

@@ -0,0 +1,1103 @@
+'use strict';
+
+var crypto = require('crypto');
+var agentlensCore = require('@farzanhossans/agentlens-core');
+
+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/registry.ts
+var LLM_REGISTRY = {
+  "api.openai.com": {
+    provider: "openai",
+    parser: "openai",
+    paths: ["/v1/chat/completions", "/v1/completions", "/v1/embeddings"]
+  },
+  "api.anthropic.com": {
+    provider: "anthropic",
+    parser: "anthropic",
+    paths: ["/v1/messages"]
+  },
+  "generativelanguage.googleapis.com": {
+    provider: "gemini",
+    parser: "gemini",
+    paths: ["/v1beta/models", "/v1/models"]
+  },
+  "api.cohere.com": {
+    provider: "cohere",
+    parser: "cohere",
+    paths: ["/v1/chat", "/v1/generate", "/v2/chat"]
+  },
+  "api.mistral.ai": {
+    provider: "mistral",
+    parser: "mistral",
+    paths: ["/v1/chat/completions"]
+  }
+};
+function matchLLM(url) {
+  try {
+    const parsed = new URL(url);
+    const entry = LLM_REGISTRY[parsed.hostname];
+    if (!entry) return null;
+    const pathMatch = entry.paths.some((p) => parsed.pathname.startsWith(p));
+    return pathMatch ? entry : null;
+  } catch {
+    return null;
+  }
+}
+function matchHostPath(host, path) {
+  const entry = LLM_REGISTRY[host];
+  if (!entry) return null;
+  const pathMatch = entry.paths.some((p) => path.startsWith(p));
+  return pathMatch ? entry : null;
+}
+
+// src/streaming/sse.ts
+async function captureSSEStream(stream, ctx) {
+  const reader = stream.getReader();
+  const decoder = new TextDecoder();
+  let raw = "";
+  try {
+    let done = false;
+    while (!done) {
+      const chunk = await reader.read();
+      done = chunk.done;
+      if (chunk.value) raw += decoder.decode(chunk.value, { stream: true });
+    }
+    raw += decoder.decode();
+  } catch {
+    return;
+  }
+  const parsed = parseStream(raw, ctx.llm.parser);
+  const response = synthesizeResponse(parsed, ctx.llm.parser, ctx.requestBody);
+  ctx.transport.push({
+    provider: ctx.llm.provider,
+    parser: ctx.llm.parser,
+    request: ctx.requestBody,
+    response,
+    latency: ctx.latency,
+    status: 200,
+    isStream: true
+  });
+}
+function parseStream(raw, parser) {
+  switch (parser) {
+    case "anthropic":
+      return parseAnthropicSSE(raw);
+    case "gemini":
+      return parseGeminiSSE(raw);
+    case "cohere":
+      return parseCohereSSE(raw);
+    case "openai":
+    case "mistral":
+      return parseOpenAISSE(raw);
+  }
+}
+function parseOpenAISSE(raw) {
+  let outputText = "";
+  let inputTokens = 0;
+  let outputTokens = 0;
+  for (const line of raw.split("\n")) {
+    if (!line.startsWith("data: ")) continue;
+    const data = line.slice(6).trim();
+    if (data === "" || data === "[DONE]") continue;
+    try {
+      const evt = JSON.parse(data);
+      const choice = evt.choices?.[0];
+      if (choice?.delta?.content) outputText += choice.delta.content;
+      else if (typeof choice?.text === "string") outputText += choice.text;
+      if (evt.usage) {
+        if (typeof evt.usage.prompt_tokens === "number") inputTokens = evt.usage.prompt_tokens;
+        if (typeof evt.usage.completion_tokens === "number") outputTokens = evt.usage.completion_tokens;
+      }
+    } catch {
+      continue;
+    }
+  }
+  return { outputText, inputTokens, outputTokens };
+}
+function parseAnthropicSSE(raw) {
+  let outputText = "";
+  let inputTokens = 0;
+  let outputTokens = 0;
+  for (const line of raw.split("\n")) {
+    if (!line.startsWith("data: ")) continue;
+    const data = line.slice(6).trim();
+    if (data === "" || data === "[DONE]") continue;
+    try {
+      const evt = JSON.parse(data);
+      if (evt.type === "content_block_delta" && evt.delta?.type === "text_delta" && evt.delta.text) {
+        outputText += evt.delta.text;
+      }
+      const u = evt.message?.usage ?? evt.usage;
+      if (u) {
+        if (typeof u.input_tokens === "number") inputTokens = u.input_tokens;
+        if (typeof u.output_tokens === "number") outputTokens = u.output_tokens;
+      }
+    } catch {
+      continue;
+    }
+  }
+  return { outputText, inputTokens, outputTokens };
+}
+function parseGeminiSSE(raw) {
+  let outputText = "";
+  let inputTokens = 0;
+  let outputTokens = 0;
+  const candidates = extractGeminiJsonChunks(raw);
+  for (const evt of candidates) {
+    const evtCandidates = evt.candidates;
+    if (Array.isArray(evtCandidates)) {
+      for (const c of evtCandidates) {
+        const parts = c.content?.parts;
+        if (Array.isArray(parts)) {
+          for (const p of parts) {
+            if (typeof p.text === "string") outputText += p.text;
+          }
+        }
+      }
+    }
+    const usage = evt.usageMetadata;
+    if (usage) {
+      if (typeof usage.promptTokenCount === "number") inputTokens = usage.promptTokenCount;
+      if (typeof usage.candidatesTokenCount === "number") outputTokens = usage.candidatesTokenCount;
+    }
+  }
+  return { outputText, inputTokens, outputTokens };
+}
+function extractGeminiJsonChunks(raw) {
+  const out = [];
+  for (const line of raw.split("\n")) {
+    if (!line.startsWith("data: ")) continue;
+    const body = line.slice(6).trim();
+    if (!body || body === "[DONE]") continue;
+    try {
+      out.push(JSON.parse(body));
+    } catch {
+      continue;
+    }
+  }
+  if (out.length > 0) return out;
+  try {
+    const parsed = JSON.parse(raw.trim());
+    if (Array.isArray(parsed)) return parsed;
+    if (parsed && typeof parsed === "object") return [parsed];
+  } catch {
+  }
+  return out;
+}
+function parseCohereSSE(raw) {
+  let outputText = "";
+  let inputTokens = 0;
+  let outputTokens = 0;
+  for (const line of raw.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    const body = trimmed.startsWith("data: ") ? trimmed.slice(6).trim() : trimmed;
+    if (!body || body === "[DONE]" || body.startsWith("event:")) continue;
+    let evt;
+    try {
+      evt = JSON.parse(body);
+    } catch {
+      continue;
+    }
+    if (evt.event_type === "text-generation" && typeof evt.text === "string") {
+      outputText += evt.text;
+    }
+    if (evt.event_type === "stream-end") {
+      const resp = evt.response;
+      const billed = resp?.meta?.billed_units;
+      if (billed) {
+        if (typeof billed.input_tokens === "number") inputTokens = billed.input_tokens;
+        if (typeof billed.output_tokens === "number") outputTokens = billed.output_tokens;
+      }
+    }
+    const delta = evt.delta;
+    const text = delta?.message?.content?.text;
+    if (typeof text === "string") outputText += text;
+    const tokens = delta?.usage?.tokens;
+    if (tokens) {
+      if (typeof tokens.input_tokens === "number") inputTokens = tokens.input_tokens;
+      if (typeof tokens.output_tokens === "number") outputTokens = tokens.output_tokens;
+    }
+  }
+  return { outputText, inputTokens, outputTokens };
+}
+function synthesizeResponse(parsed, parser, request) {
+  const model = request?.model ?? "unknown";
+  switch (parser) {
+    case "anthropic":
+      return {
+        model,
+        content: [{ type: "text", text: parsed.outputText }],
+        usage: {
+          input_tokens: parsed.inputTokens,
+          output_tokens: parsed.outputTokens
+        }
+      };
+    case "openai":
+    case "mistral":
+      return {
+        model,
+        choices: [{ message: { content: parsed.outputText, role: "assistant" } }],
+        usage: {
+          prompt_tokens: parsed.inputTokens,
+          completion_tokens: parsed.outputTokens,
+          total_tokens: parsed.inputTokens + parsed.outputTokens
+        }
+      };
+    case "gemini":
+      return {
+        modelVersion: model,
+        candidates: [{ content: { parts: [{ text: parsed.outputText }] } }],
+        usageMetadata: {
+          promptTokenCount: parsed.inputTokens,
+          candidatesTokenCount: parsed.outputTokens,
+          totalTokenCount: parsed.inputTokens + parsed.outputTokens
+        }
+      };
+    case "cohere":
+      return {
+        text: parsed.outputText,
+        meta: {
+          billed_units: {
+            input_tokens: parsed.inputTokens,
+            output_tokens: parsed.outputTokens
+          }
+        }
+      };
+  }
+}
+
+// src/interceptors/fetch.ts
+function patchFetch(transport2) {
+  const original = globalThis.fetch;
+  if (!original) return;
+  if (original.__agentlens_patched) return;
+  globalThis.__agentlens_originalFetch = original;
+  const patched = async (input, init) => {
+    const url = typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
+    const llm = matchLLM(url);
+    if (!llm) return original(input, init);
+    const start = Date.now();
+    let requestBody = null;
+    const rawBody = init?.body ?? null;
+    if (typeof rawBody === "string") {
+      try {
+        requestBody = JSON.parse(rawBody);
+      } catch {
+        requestBody = null;
+      }
+    } else if (rawBody && rawBody instanceof ArrayBuffer) {
+      try {
+        const text = new TextDecoder().decode(rawBody);
+        requestBody = JSON.parse(text);
+      } catch {
+        requestBody = null;
+      }
+    }
+    const isStream = requestBody?.stream === true;
+    try {
+      const response = await original(input, init);
+      const latency = Date.now() - start;
+      if (isStream && response.body) {
+        const [userStream, ourStream] = response.body.tee();
+        void captureSSEStream(ourStream, {
+          llm,
+          requestBody,
+          latency,
+          transport: transport2
+        });
+        return new Response(userStream, {
+          status: response.status,
+          statusText: response.statusText,
+          headers: response.headers
+        });
+      }
+      const clone = response.clone();
+      const responseBody = await clone.json().catch(() => null);
+      if (responseBody) {
+        transport2.push({
+          provider: llm.provider,
+          parser: llm.parser,
+          request: requestBody,
+          response: responseBody,
+          latency,
+          status: response.status,
+          isStream: false
+        });
+      }
+      return response;
+    } catch (err) {
+      transport2.pushError({
+        provider: llm.provider,
+        request: requestBody,
+        error: err instanceof Error ? err.message : String(err),
+        latency: Date.now() - start
+      });
+      throw err;
+    }
+  };
+  patched.__agentlens_patched = true;
+  globalThis.fetch = patched;
+}
+
+// src/interceptors/https.ts
+function patchHttps(transport2) {
+  if (typeof process === "undefined" || typeof __require === "undefined") {
+    return;
+  }
+  try {
+    patchModule("https", transport2);
+    patchModule("http", transport2);
+  } catch {
+  }
+}
+function patchModule(name, transport2) {
+  let mod;
+  try {
+    mod = __require(name);
+  } catch {
+    return;
+  }
+  if (mod.__agentlens_patched) return;
+  const original = mod.request.bind(mod);
+  mod.request = function patchedRequest(...args) {
+    const ctx = extractContext(args);
+    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) {
+      try {
+        if (chunk) requestChunks.push(toBuffer(chunk));
+      } catch {
+      }
+      return originalWrite(chunk, ...rest);
+    };
+    req.on("response", (...resArgs) => {
+      const res = resArgs[0];
+      res.on("data", (chunk) => {
+        try {
+          responseChunks.push(toBuffer(chunk));
+        } catch {
+        }
+      });
+      res.on("end", () => {
+        const latency = Date.now() - start;
+        const requestText = Buffer.concat(requestChunks).toString("utf8");
+        const responseText = Buffer.concat(responseChunks).toString("utf8");
+        const requestBody = safeParse(requestText);
+        const responseBody = safeParse(responseText);
+        if (responseBody) {
+          transport2.push({
+            provider: ctx.llm.provider,
+            parser: ctx.llm.parser,
+            request: requestBody,
+            response: responseBody,
+            latency,
+            status: res.statusCode ?? 0,
+            isStream: requestBody?.stream === true
+          });
+        }
+      });
+    });
+    req.on("error", (...errArgs) => {
+      const err = errArgs[0];
+      const requestText = Buffer.concat(requestChunks).toString("utf8");
+      transport2.pushError({
+        provider: ctx.llm.provider,
+        request: safeParse(requestText),
+        error: err?.message ?? String(err),
+        latency: Date.now() - start
+      });
+    });
+    return req;
+  };
+  mod.__agentlens_patched = true;
+}
+function extractContext(args) {
+  let host;
+  let path;
+  const first = args[0];
+  if (typeof first === "string") {
+    try {
+      const u = new URL(first);
+      host = u.hostname;
+      path = u.pathname + u.search;
+    } catch {
+      return null;
+    }
+  } else if (first instanceof URL) {
+    host = first.hostname;
+    path = first.pathname + first.search;
+  } else if (first && typeof first === "object") {
+    const opts = first;
+    host = opts.hostname ?? opts.host;
+    path = opts.path ?? "/";
+  }
+  if (args.length > 1 && typeof args[1] === "object" && args[1] !== null && !(args[1] instanceof URL)) {
+    const opts = args[1];
+    if (!host) host = opts.hostname ?? opts.host;
+    if (!path || path === "/") path = opts.path ?? path;
+  }
+  if (!host || !path) return null;
+  const pathOnly = path.split("?")[0];
+  const llm = matchHostPath(host, pathOnly);
+  if (!llm) return null;
+  return { llm };
+}
+function toBuffer(chunk) {
+  if (Buffer.isBuffer(chunk)) return chunk;
+  if (typeof chunk === "string") return Buffer.from(chunk);
+  if (chunk instanceof Uint8Array) return Buffer.from(chunk);
+  return Buffer.from(String(chunk));
+}
+function safeParse(text) {
+  if (!text) return null;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
+}
+
+// src/parsers/anthropic.ts
+var ANTHROPIC_COSTS = {
+  "claude-opus-4-6": { input: 15e-6, output: 75e-6 },
+  "claude-sonnet-4-6": { input: 3e-6, output: 15e-6 },
+  "claude-haiku-4-5": { input: 25e-8, output: 125e-8 },
+  "claude-3-opus": { input: 15e-6, output: 75e-6 },
+  "claude-3-sonnet": { input: 3e-6, output: 15e-6 },
+  "claude-3-haiku": { input: 25e-8, output: 125e-8 },
+  "claude-3-5-sonnet": { input: 3e-6, output: 15e-6 },
+  "claude-3-5-haiku": { input: 1e-6, output: 5e-6 }
+};
+function lookupCost(model) {
+  if (ANTHROPIC_COSTS[model]) return ANTHROPIC_COSTS[model];
+  for (const key of Object.keys(ANTHROPIC_COSTS)) {
+    if (model.startsWith(key)) return ANTHROPIC_COSTS[key];
+  }
+  return { input: 0, output: 0 };
+}
+function extractInputText(request) {
+  if (!request) return "";
+  const parts = [];
+  if (typeof request.system === "string") parts.push(request.system);
+  const messages = request.messages;
+  if (Array.isArray(messages)) {
+    for (const m of messages) {
+      const content = m.content;
+      if (typeof content === "string") parts.push(content);
+      else if (Array.isArray(content)) {
+        for (const block of content) {
+          const text = block.text;
+          if (typeof text === "string") parts.push(text);
+        }
+      }
+    }
+  }
+  return parts.join("\n");
+}
+function extractOutputText(response) {
+  if (!response) return "";
+  const content = response.content;
+  if (Array.isArray(content)) {
+    return content.map((block) => {
+      const b = block;
+      return b.type === "text" && typeof b.text === "string" ? b.text : "";
+    }).join("");
+  }
+  return "";
+}
+function parseAnthropic(args) {
+  const { request, response, isStream } = args;
+  const model = response?.model ?? request?.model ?? "unknown";
+  const usage = response?.usage ?? {};
+  const inputTokens = usage.input_tokens ?? 0;
+  const outputTokens = usage.output_tokens ?? 0;
+  const totalTokens = inputTokens + outputTokens;
+  const cost = lookupCost(model);
+  return {
+    model,
+    provider: "anthropic",
+    inputTokens,
+    outputTokens,
+    totalTokens,
+    costUsd: inputTokens * cost.input + outputTokens * cost.output,
+    inputText: extractInputText(request),
+    outputText: extractOutputText(response),
+    isStream
+  };
+}
+
+// src/parsers/cohere.ts
+var COHERE_COSTS = {
+  "command-r-plus": { input: 3e-6, output: 15e-6 },
+  "command-r": { input: 5e-7, output: 15e-7 },
+  "command": { input: 1e-6, output: 2e-6 },
+  "command-light": { input: 3e-7, output: 6e-7 }
+};
+function lookupCost2(model) {
+  if (COHERE_COSTS[model]) return COHERE_COSTS[model];
+  for (const key of Object.keys(COHERE_COSTS)) {
+    if (model.startsWith(key)) return COHERE_COSTS[key];
+  }
+  return { input: 0, output: 0 };
+}
+function extractInputText2(request) {
+  if (!request) return "";
+  if (typeof request.message === "string") return request.message;
+  if (typeof request.prompt === "string") return request.prompt;
+  const messages = request.messages;
+  if (Array.isArray(messages)) {
+    return messages.map((m) => {
+      const content = m.content;
+      if (typeof content === "string") return content;
+      return "";
+    }).join("\n");
+  }
+  return "";
+}
+function extractOutputText2(response) {
+  if (!response) return "";
+  if (typeof response.text === "string") return response.text;
+  const message = response.message;
+  if (message?.content && Array.isArray(message.content)) {
+    return message.content.map((c) => typeof c.text === "string" ? c.text : "").join("");
+  }
+  const generations = response.generations;
+  if (Array.isArray(generations) && generations.length > 0) {
+    const first = generations[0];
+    if (typeof first.text === "string") return first.text;
+  }
+  return "";
+}
+function parseCohere(args) {
+  const { request, response, isStream } = args;
+  const model = request?.model ?? "unknown";
+  const meta = response?.meta ?? {};
+  const usage = response?.usage ?? {};
+  const tokens = meta.billed_units ?? usage.tokens ?? {};
+  const inputTokens = tokens.input_tokens ?? 0;
+  const outputTokens = tokens.output_tokens ?? 0;
+  const cost = lookupCost2(model);
+  return {
+    model,
+    provider: "cohere",
+    inputTokens,
+    outputTokens,
+    totalTokens: inputTokens + outputTokens,
+    costUsd: inputTokens * cost.input + outputTokens * cost.output,
+    inputText: extractInputText2(request),
+    outputText: extractOutputText2(response),
+    isStream
+  };
+}
+
+// src/parsers/gemini.ts
+var GEMINI_COSTS = {
+  "gemini-1.5-pro": { input: 125e-8, output: 5e-6 },
+  "gemini-1.5-flash": { input: 75e-9, output: 3e-7 },
+  "gemini-1.0-pro": { input: 5e-7, output: 15e-7 },
+  "gemini-pro": { input: 5e-7, output: 15e-7 }
+};
+function lookupCost3(model) {
+  if (GEMINI_COSTS[model]) return GEMINI_COSTS[model];
+  for (const key of Object.keys(GEMINI_COSTS)) {
+    if (model.startsWith(key)) return GEMINI_COSTS[key];
+  }
+  return { input: 0, output: 0 };
+}
+function extractInputText3(request) {
+  if (!request) return "";
+  const contents = request.contents;
+  if (!Array.isArray(contents)) return "";
+  const parts = [];
+  for (const c of contents) {
+    const innerParts = c.parts;
+    if (Array.isArray(innerParts)) {
+      for (const p of innerParts) {
+        const text = p.text;
+        if (typeof text === "string") parts.push(text);
+      }
+    }
+  }
+  return parts.join("\n");
+}
+function extractOutputText3(response) {
+  if (!response) return "";
+  const candidates = response.candidates;
+  if (!Array.isArray(candidates) || candidates.length === 0) return "";
+  const first = candidates[0];
+  const parts = first.content?.parts;
+  if (!Array.isArray(parts)) return "";
+  return parts.map((p) => typeof p.text === "string" ? p.text : "").join("");
+}
+function parseGemini(args) {
+  const { request, response, isStream, modelHint } = args;
+  const model = response?.modelVersion ?? modelHint ?? request?.model ?? "unknown";
+  const usage = response?.usageMetadata ?? {};
+  const inputTokens = usage.promptTokenCount ?? 0;
+  const outputTokens = usage.candidatesTokenCount ?? 0;
+  const totalTokens = usage.totalTokenCount ?? inputTokens + outputTokens;
+  const cost = lookupCost3(model);
+  return {
+    model,
+    provider: "gemini",
+    inputTokens,
+    outputTokens,
+    totalTokens,
+    costUsd: inputTokens * cost.input + outputTokens * cost.output,
+    inputText: extractInputText3(request),
+    outputText: extractOutputText3(response),
+    isStream
+  };
+}
+
+// src/parsers/mistral.ts
+var MISTRAL_COSTS = {
+  "mistral-large": { input: 2e-6, output: 6e-6 },
+  "mistral-medium": { input: 27e-7, output: 81e-7 },
+  "mistral-small": { input: 2e-7, output: 6e-7 },
+  "open-mistral-7b": { input: 25e-8, output: 25e-8 },
+  "open-mixtral-8x7b": { input: 7e-7, output: 7e-7 },
+  "open-mixtral-8x22b": { input: 2e-6, output: 6e-6 }
+};
+function lookupCost4(model) {
+  if (MISTRAL_COSTS[model]) return MISTRAL_COSTS[model];
+  for (const key of Object.keys(MISTRAL_COSTS)) {
+    if (model.startsWith(key)) return MISTRAL_COSTS[key];
+  }
+  return { input: 0, output: 0 };
+}
+function extractInputText4(request) {
+  if (!request) return "";
+  const messages = request.messages;
+  if (Array.isArray(messages)) {
+    return messages.map((m) => {
+      const content = m.content;
+      return typeof content === "string" ? content : "";
+    }).join("\n");
+  }
+  return "";
+}
+function extractOutputText4(response) {
+  if (!response) return "";
+  const choices = response.choices;
+  if (Array.isArray(choices) && choices.length > 0) {
+    const first = choices[0];
+    if (first.message?.content) return first.message.content;
+  }
+  return "";
+}
+function parseMistral(args) {
+  const { request, response, isStream } = args;
+  const model = response?.model ?? request?.model ?? "unknown";
+  const usage = response?.usage ?? {};
+  const inputTokens = usage.prompt_tokens ?? 0;
+  const outputTokens = usage.completion_tokens ?? 0;
+  const totalTokens = usage.total_tokens ?? inputTokens + outputTokens;
+  const cost = lookupCost4(model);
+  return {
+    model,
+    provider: "mistral",
+    inputTokens,
+    outputTokens,
+    totalTokens,
+    costUsd: inputTokens * cost.input + outputTokens * cost.output,
+    inputText: extractInputText4(request),
+    outputText: extractOutputText4(response),
+    isStream
+  };
+}
+
+// src/parsers/openai.ts
+var OPENAI_COSTS = {
+  "gpt-4o": { input: 25e-7, output: 1e-5 },
+  "gpt-4o-mini": { input: 15e-8, output: 6e-7 },
+  "gpt-4-turbo": { input: 1e-5, output: 3e-5 },
+  "gpt-4": { input: 3e-5, output: 6e-5 },
+  "gpt-3.5-turbo": { input: 5e-7, output: 15e-7 },
+  "text-embedding-3-small": { input: 2e-8, output: 0 },
+  "text-embedding-3-large": { input: 13e-8, output: 0 }
+};
+function lookupCost5(model) {
+  if (OPENAI_COSTS[model]) return OPENAI_COSTS[model];
+  for (const key of Object.keys(OPENAI_COSTS)) {
+    if (model.startsWith(key)) return OPENAI_COSTS[key];
+  }
+  return { input: 0, output: 0 };
+}
+function extractInputText5(request) {
+  if (!request) return "";
+  const messages = request.messages;
+  if (Array.isArray(messages)) {
+    return messages.map((m) => {
+      const content = m.content;
+      if (typeof content === "string") return content;
+      if (Array.isArray(content)) {
+        return content.map((part) => typeof part.text === "string" ? part.text : "").join("");
+      }
+      return "";
+    }).join("\n");
+  }
+  if (typeof request.prompt === "string") return request.prompt;
+  if (Array.isArray(request.input)) return request.input.map((x) => String(x)).join("\n");
+  if (typeof request.input === "string") return request.input;
+  return "";
+}
+function extractOutputText5(response) {
+  if (!response) return "";
+  const choices = response.choices;
+  if (Array.isArray(choices) && choices.length > 0) {
+    const first = choices[0];
+    if (first.message?.content) return first.message.content;
+    if (typeof first.text === "string") return first.text;
+  }
+  return "";
+}
+function parseOpenAI(args) {
+  const { request, response, isStream } = args;
+  const model = response?.model ?? request?.model ?? "unknown";
+  const usage = response?.usage ?? {};
+  const inputTokens = usage.prompt_tokens ?? 0;
+  const outputTokens = usage.completion_tokens ?? 0;
+  const totalTokens = usage.total_tokens ?? inputTokens + outputTokens;
+  const cost = lookupCost5(model);
+  const costUsd = inputTokens * cost.input + outputTokens * cost.output;
+  return {
+    model,
+    provider: "openai",
+    inputTokens,
+    outputTokens,
+    totalTokens,
+    costUsd,
+    inputText: extractInputText5(request),
+    outputText: extractOutputText5(response),
+    isStream
+  };
+}
+
+// src/parsers/index.ts
+function parseSpan(args) {
+  switch (args.parser) {
+    case "openai":
+      return parseOpenAI(args);
+    case "anthropic":
+      return parseAnthropic(args);
+    case "gemini":
+      return parseGemini(args);
+    case "cohere":
+      return parseCohere(args);
+    case "mistral":
+      return parseMistral(args);
+  }
+}
+
+// src/pii/scrubber.ts
+var PII_PATTERNS = [
+  { name: "email", pattern: /[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g, replacement: "[EMAIL]" },
+  { name: "apikey", pattern: /\b(sk|pk|key|token|secret|api[-_]?key)[-_]?[a-zA-Z0-9]{20,}/gi, replacement: "[API_KEY]" },
+  { name: "creditcard", pattern: /\b\d{4}[\s-]?\d{4}[\s-]?\d{4}[\s-]?\d{4}\b/g, replacement: "[CARD]" },
+  { name: "ssn", pattern: /\b\d{3}-\d{2}-\d{4}\b/g, replacement: "[SSN]" },
+  { name: "phone", pattern: /(\+?\d{1,3}[\s-]?)?\(?\d{3}\)?[\s-]?\d{3}[\s-]?\d{4}/g, replacement: "[PHONE]" },
+  { name: "ipv4", pattern: /\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b/g, replacement: "[IP]" }
+];
+function scrubPII(text) {
+  let result = text;
+  for (const { pattern, replacement } of PII_PATTERNS) {
+    result = result.replace(pattern, replacement);
+  }
+  return result;
+}
+function scrubObject(obj) {
+  if (typeof obj === "string") return scrubPII(obj);
+  if (Array.isArray(obj)) return obj.map(scrubObject);
+  if (obj && typeof obj === "object") {
+    return Object.fromEntries(Object.entries(obj).map(([k, v]) => [k, scrubObject(v)]));
+  }
+  return obj;
+}
+
+// src/transport.ts
+var DEFAULT_FLUSH_INTERVAL_MS = 500;
+var DEFAULT_MAX_BATCH_SIZE = 50;
+var MAX_RETRIES = 3;
+var Transport = class {
+  config;
+  queue = [];
+  timer = null;
+  flushing = false;
+  exitHandlerRegistered = false;
+  constructor(config) {
+    this.config = {
+      apiKey: config.apiKey,
+      endpoint: config.endpoint,
+      flushIntervalMs: config.flushIntervalMs ?? DEFAULT_FLUSH_INTERVAL_MS,
+      maxBatchSize: config.maxBatchSize ?? DEFAULT_MAX_BATCH_SIZE,
+      debug: config.debug ?? false,
+      pii: config.pii ?? true
+    };
+    this.startTimer();
+    this.registerExitHandler();
+  }
+  push(payload) {
+    let parsed;
+    try {
+      parsed = parseSpan({
+        parser: payload.parser,
+        request: payload.request ?? null,
+        response: payload.response ?? null,
+        isStream: payload.isStream
+      });
+    } catch (err) {
+      if (this.config.debug) {
+        console.warn("[agentlens] parser failed", err);
+      }
+      return;
+    }
+    const outbound = this.toOutbound(parsed, payload.latency, payload.status);
+    this.enqueue(outbound);
+  }
+  pushError(payload) {
+    const ids = this.resolveIds();
+    const span = {
+      spanId: ids.spanId,
+      traceId: ids.traceId,
+      parentSpanId: ids.parentSpanId,
+      model: "unknown",
+      provider: payload.provider,
+      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()
+    };
+    this.enqueue(span);
+  }
+  async flush() {
+    if (this.flushing) return;
+    if (this.queue.length === 0) return;
+    this.flushing = true;
+    const batch = this.queue.splice(0, this.queue.length);
+    try {
+      await this.send(batch);
+    } catch {
+    } finally {
+      this.flushing = false;
+    }
+  }
+  shutdown() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+  }
+  toOutbound(parsed, latency, status) {
+    const ids = this.resolveIds();
+    return {
+      ...parsed,
+      spanId: ids.spanId,
+      traceId: ids.traceId,
+      parentSpanId: ids.parentSpanId,
+      inputText: this.scrub(parsed.inputText),
+      outputText: this.scrub(parsed.outputText),
+      latency,
+      status,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  /**
+   * Resolves the trace-context IDs to stamp on an outbound span.
+   *
+   * - `spanId` is always fresh per LLM call (the call IS the leaf span).
+   * - `traceId` reuses the surrounding `trace()` block's traceId if any,
+   *   else a new one (the standalone LLM call is its own single-span trace).
+   * - `parentSpanId` is the surrounding trace's currentSpanId, or undefined
+   *   when there is no enclosing `trace()`.
+   *
+   * AsyncLocalStorage propagates through the patched fetch's promise chain,
+   * so this still resolves correctly for streamed spans emitted from the
+   * background `captureSSEStream()` reader.
+   */
+  resolveIds() {
+    return {
+      spanId: crypto.randomUUID(),
+      traceId: agentlensCore.getCurrentTraceId() ?? crypto.randomUUID(),
+      parentSpanId: agentlensCore.getCurrentSpanId()
+    };
+  }
+  scrub(text) {
+    if (!this.config.pii) return text;
+    return scrubPII(text);
+  }
+  stringifyRequest(request) {
+    if (request == null) return "";
+    if (typeof request === "string") return request;
+    try {
+      return JSON.stringify(request);
+    } catch {
+      return "";
+    }
+  }
+  enqueue(span) {
+    if (this.config.debug) {
+      console.log("[agentlens] span", {
+        model: span.model,
+        provider: span.provider,
+        inputTokens: span.inputTokens,
+        outputTokens: span.outputTokens,
+        costUsd: span.costUsd,
+        latency: span.latency,
+        isStream: span.isStream
+      });
+    }
+    this.queue.push(span);
+    if (this.queue.length >= this.config.maxBatchSize) {
+      void this.flush();
+    }
+  }
+  startTimer() {
+    if (this.timer) return;
+    this.timer = setInterval(() => {
+      void this.flush();
+    }, this.config.flushIntervalMs);
+    if (typeof this.timer.unref === "function") {
+      this.timer.unref();
+    }
+  }
+  registerExitHandler() {
+    if (this.exitHandlerRegistered) return;
+    if (typeof process === "undefined" || typeof process.on !== "function") return;
+    this.exitHandlerRegistered = true;
+    process.on("beforeExit", () => {
+      void this.flush();
+    });
+  }
+  async send(batch) {
+    const body = JSON.stringify({ spans: batch });
+    let attempt = 0;
+    let delay = 100;
+    while (attempt < MAX_RETRIES) {
+      try {
+        const res = await this.doFetch(body);
+        if (res.ok) return;
+        if (res.status >= 400 && res.status < 500) {
+          if (this.config.debug) {
+            console.warn("[agentlens] flush rejected", res.status);
+          }
+          return;
+        }
+      } catch {
+      }
+      attempt++;
+      if (attempt < MAX_RETRIES) {
+        await sleep(delay);
+        delay *= 2;
+      }
+    }
+    if (this.config.debug) {
+      console.warn("[agentlens] flush gave up after", MAX_RETRIES, "attempts");
+    }
+  }
+  async doFetch(body) {
+    const f = globalThis.__agentlens_originalFetch ?? globalThis.fetch;
+    if (!f) {
+      throw new Error("fetch unavailable");
+    }
+    const res = await f(this.config.endpoint, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        authorization: `Bearer ${this.config.apiKey}`
+      },
+      body
+    });
+    return { ok: res.ok, status: res.status };
+  }
+};
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+var DEFAULT_ENDPOINT = "https://ingest.agentlens.dev/v1/spans";
+var initialized = false;
+var transport = null;
+var AgentLens = {
+  init(config) {
+    if (initialized) return;
+    if (!config?.apiKey) {
+      throw new Error("AgentLens.init requires an apiKey");
+    }
+    initialized = true;
+    transport = new Transport({
+      apiKey: config.apiKey,
+      endpoint: config.endpoint ?? DEFAULT_ENDPOINT,
+      debug: config.debug ?? false,
+      pii: config.pii ?? true,
+      flushIntervalMs: config.flushIntervalMs,
+      maxBatchSize: config.maxBatchSize
+    });
+    patchFetch(transport);
+    patchHttps(transport);
+  },
+  async flush() {
+    if (!transport) return;
+    await transport.flush();
+  },
+  shutdown() {
+    if (!transport) return;
+    transport.shutdown();
+    transport = null;
+    initialized = false;
+  },
+  /**
+   * Wraps `fn` in a named trace context. Any LLM calls made inside `fn`
+   * (including async ones) are auto-tagged with this trace's `traceId` and
+   * get `parentSpanId` set to this trace's `spanId`. Nested `trace()` calls
+   * become child spans automatically.
+   *
+   * Use this to group multiple LLM calls that belong to the same agent run.
+   */
+  trace(_name, fn) {
+    const spanId = crypto.randomUUID();
+    const traceId = agentlensCore.getCurrentTraceId() ?? crypto.randomUUID();
+    return agentlensCore.runWithTrace({ traceId, currentSpanId: spanId }, fn);
+  }
+};
+
+Object.defineProperty(exports, "getCurrentSpanId", {
+  enumerable: true,
+  get: function () { return agentlensCore.getCurrentSpanId; }
+});
+Object.defineProperty(exports, "getCurrentTrace", {
+  enumerable: true,
+  get: function () { return agentlensCore.getCurrentTrace; }
+});
+Object.defineProperty(exports, "getCurrentTraceId", {
+  enumerable: true,
+  get: function () { return agentlensCore.getCurrentTraceId; }
+});
+Object.defineProperty(exports, "runWithTrace", {
+  enumerable: true,
+  get: function () { return agentlensCore.runWithTrace; }
+});
+exports.AgentLens = AgentLens;
+exports.LLM_REGISTRY = LLM_REGISTRY;
+exports.matchLLM = matchLLM;
+exports.scrubObject = scrubObject;
+exports.scrubPII = scrubPII;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map