agentracer 0.1.0

package/dist/openai.js

@@ -0,0 +1,223 @@
+"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/openai.ts
+var openai_exports = {};
+__export(openai_exports, {
+  TrackedOpenAI: () => TrackedOpenAI,
+  _setClientForTesting: () => _setClientForTesting,
+  openai: () => openai
+});
+module.exports = __toCommonJS(openai_exports);
+
+// src/index.ts
+var import_async_hooks = require("async_hooks");
+var config = {
+  trackerApiKey: "",
+  projectId: "",
+  environment: "production",
+  host: "https://api.agentracer.dev",
+  debug: false,
+  enabled: true
+};
+var featureTagStorage = new import_async_hooks.AsyncLocalStorage();
+var runStorage = new import_async_hooks.AsyncLocalStorage();
+async function sendTelemetry(payload) {
+  if (!config.enabled) return;
+  try {
+    if (config.debug) console.log("[agentracer]", payload);
+    const response = await fetch(`${config.host}/api/ingest`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-api-key": config.trackerApiKey
+      },
+      body: JSON.stringify(payload),
+      signal: AbortSignal.timeout(2e3)
+    });
+  } catch {
+  }
+}
+async function track(options) {
+  const currentTag = featureTagStorage.getStore();
+  let runId = options.runId;
+  let stepIndex = options.stepIndex;
+  const activeRun = runStorage.getStore();
+  if (activeRun && runId == null) {
+    runId = activeRun.runId;
+    stepIndex = activeRun._nextStep();
+    sendRunApi("/api/runs/step", {
+      project_id: config.projectId,
+      run_id: activeRun.runId,
+      step_index: stepIndex,
+      step_type: "llm_call",
+      model: options.model,
+      provider: options.provider ?? "custom",
+      input_tokens: options.inputTokens,
+      output_tokens: options.outputTokens,
+      cached_tokens: options.cachedTokens ?? 0,
+      cost_usd: 0,
+      latency_ms: options.latencyMs,
+      success: options.success ?? true,
+      error_type: options.errorType ?? null
+    }).catch(() => {
+    });
+  }
+  const payload = {
+    project_id: config.projectId,
+    provider: options.provider ?? "custom",
+    model: options.model,
+    feature_tag: options.featureTag ?? currentTag ?? "unknown",
+    input_tokens: options.inputTokens,
+    output_tokens: options.outputTokens,
+    cached_tokens: options.cachedTokens ?? 0,
+    latency_ms: options.latencyMs,
+    success: options.success ?? true,
+    environment: options.environment ?? config.environment
+  };
+  if (options.errorType != null) payload.error_type = options.errorType;
+  if (options.endUserId != null) payload.end_user_id = options.endUserId;
+  if (runId != null) payload.run_id = runId;
+  if (stepIndex != null) payload.step_index = stepIndex;
+  await sendTelemetry(payload);
+}
+async function sendRunApi(path, payload) {
+  if (!config.enabled) return;
+  try {
+    await fetch(`${config.host}${path}`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-api-key": config.trackerApiKey
+      },
+      body: JSON.stringify(payload),
+      signal: AbortSignal.timeout(2e3)
+    });
+  } catch {
+  }
+}
+
+// src/openai.ts
+var _clientInstance = null;
+function getClient(opts) {
+  if (opts) {
+    const OpenAI = require("openai").default || require("openai");
+    return new OpenAI(opts);
+  }
+  if (!_clientInstance) {
+    const OpenAI = require("openai").default || require("openai");
+    _clientInstance = new OpenAI();
+  }
+  return _clientInstance;
+}
+function _setClientForTesting(client) {
+  _clientInstance = client;
+}
+async function* wrapOpenAIStream(stream, model, featureTag, start) {
+  let inputTokens = 0;
+  let outputTokens = 0;
+  for await (const chunk of stream) {
+    if (chunk.usage) {
+      inputTokens = chunk.usage.prompt_tokens ?? 0;
+      outputTokens = chunk.usage.completion_tokens ?? 0;
+    }
+    yield chunk;
+  }
+  track({
+    model,
+    inputTokens,
+    outputTokens,
+    latencyMs: Date.now() - start,
+    featureTag,
+    provider: "openai"
+  }).catch(() => {
+  });
+}
+function createOpenAIProxy(clientGetter) {
+  return new Proxy({}, {
+    get(_, prop) {
+      if (prop === "chat") {
+        return {
+          completions: {
+            create: async (params) => {
+              const featureTag = params.feature_tag ?? featureTagStorage.getStore() ?? "unknown";
+              const { feature_tag, ...cleanParams } = params;
+              const start = Date.now();
+              const client = clientGetter();
+              if (cleanParams.stream) {
+                cleanParams.stream_options = {
+                  ...cleanParams.stream_options,
+                  include_usage: true
+                };
+                const stream = await client.chat.completions.create(cleanParams);
+                return wrapOpenAIStream(stream, params.model, featureTag, start);
+              }
+              let response;
+              try {
+                response = await client.chat.completions.create(cleanParams);
+              } catch (err) {
+                track({
+                  model: params.model,
+                  inputTokens: 0,
+                  outputTokens: 0,
+                  latencyMs: Date.now() - start,
+                  featureTag,
+                  provider: "openai",
+                  success: false,
+                  errorType: err?.constructor?.name ?? "Error"
+                }).catch(() => {
+                });
+                throw err;
+              }
+              track({
+                model: params.model,
+                inputTokens: response.usage?.prompt_tokens ?? 0,
+                outputTokens: response.usage?.completion_tokens ?? 0,
+                cachedTokens: response.usage?.prompt_tokens_details?.cached_tokens ?? 0,
+                latencyMs: Date.now() - start,
+                featureTag,
+                provider: "openai"
+              }).catch(() => {
+              });
+              return response;
+            }
+          }
+        };
+      }
+      return clientGetter()[prop];
+    }
+  });
+}
+var TrackedOpenAI = class {
+  constructor(options) {
+    const OpenAI = require("openai").default || require("openai");
+    const client = new OpenAI(options);
+    this._proxy = createOpenAIProxy(() => client);
+  }
+  get chat() {
+    return this._proxy.chat;
+  }
+};
+var openai = createOpenAIProxy(() => getClient());
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TrackedOpenAI,
+  _setClientForTesting,
+  openai
+});

package/dist/openai.mjs

@@ -0,0 +1,113 @@
+import {
+  __require,
+  featureTagStorage,
+  track
+} from "./chunk-72GBZ4TW.mjs";
+
+// src/openai.ts
+var _clientInstance = null;
+function getClient(opts) {
+  if (opts) {
+    const OpenAI = __require("openai").default || __require("openai");
+    return new OpenAI(opts);
+  }
+  if (!_clientInstance) {
+    const OpenAI = __require("openai").default || __require("openai");
+    _clientInstance = new OpenAI();
+  }
+  return _clientInstance;
+}
+function _setClientForTesting(client) {
+  _clientInstance = client;
+}
+async function* wrapOpenAIStream(stream, model, featureTag, start) {
+  let inputTokens = 0;
+  let outputTokens = 0;
+  for await (const chunk of stream) {
+    if (chunk.usage) {
+      inputTokens = chunk.usage.prompt_tokens ?? 0;
+      outputTokens = chunk.usage.completion_tokens ?? 0;
+    }
+    yield chunk;
+  }
+  track({
+    model,
+    inputTokens,
+    outputTokens,
+    latencyMs: Date.now() - start,
+    featureTag,
+    provider: "openai"
+  }).catch(() => {
+  });
+}
+function createOpenAIProxy(clientGetter) {
+  return new Proxy({}, {
+    get(_, prop) {
+      if (prop === "chat") {
+        return {
+          completions: {
+            create: async (params) => {
+              const featureTag = params.feature_tag ?? featureTagStorage.getStore() ?? "unknown";
+              const { feature_tag, ...cleanParams } = params;
+              const start = Date.now();
+              const client = clientGetter();
+              if (cleanParams.stream) {
+                cleanParams.stream_options = {
+                  ...cleanParams.stream_options,
+                  include_usage: true
+                };
+                const stream = await client.chat.completions.create(cleanParams);
+                return wrapOpenAIStream(stream, params.model, featureTag, start);
+              }
+              let response;
+              try {
+                response = await client.chat.completions.create(cleanParams);
+              } catch (err) {
+                track({
+                  model: params.model,
+                  inputTokens: 0,
+                  outputTokens: 0,
+                  latencyMs: Date.now() - start,
+                  featureTag,
+                  provider: "openai",
+                  success: false,
+                  errorType: err?.constructor?.name ?? "Error"
+                }).catch(() => {
+                });
+                throw err;
+              }
+              track({
+                model: params.model,
+                inputTokens: response.usage?.prompt_tokens ?? 0,
+                outputTokens: response.usage?.completion_tokens ?? 0,
+                cachedTokens: response.usage?.prompt_tokens_details?.cached_tokens ?? 0,
+                latencyMs: Date.now() - start,
+                featureTag,
+                provider: "openai"
+              }).catch(() => {
+              });
+              return response;
+            }
+          }
+        };
+      }
+      return clientGetter()[prop];
+    }
+  });
+}
+var TrackedOpenAI = class {
+  constructor(options) {
+    const OpenAI = __require("openai").default || __require("openai");
+    const client = new OpenAI(options);
+    this._proxy = createOpenAIProxy(() => client);
+  }
+  get chat() {
+    return this._proxy.chat;
+  }
+};
+var openai = createOpenAIProxy(() => getClient());
+export {
+  TrackedOpenAI,
+  _setClientForTesting,
+  openai
+};

package/package.json

@@ -0,0 +1,85 @@
+{
+  "name": "agentracer",
+  "version": "0.1.0",
+  "description": "Lightweight AI incident detection. Catch cost spikes, latency anomalies, and prompt bloat before they hit your users.",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    },
+    "./openai": {
+      "types": "./dist/openai.d.ts",
+      "import": "./dist/openai.mjs",
+      "require": "./dist/openai.js"
+    },
+    "./anthropic": {
+      "types": "./dist/anthropic.d.ts",
+      "import": "./dist/anthropic.mjs",
+      "require": "./dist/anthropic.js"
+    },
+    "./gemini": {
+      "types": "./dist/gemini.d.ts",
+      "import": "./dist/gemini.mjs",
+      "require": "./dist/gemini.js"
+    }
+  },
+  "scripts": {
+    "build": "tsup src/index.ts src/openai.ts src/anthropic.ts src/gemini.ts --format cjs,esm --dts",
+    "dev": "tsup src/index.ts src/openai.ts src/anthropic.ts src/gemini.ts --format cjs,esm --dts --watch",
+    "test": "vitest run",
+    "prepublishOnly": "npm run build && npm test"
+  },
+  "keywords": [
+    "ai",
+    "observability",
+    "llm",
+    "cost-tracking",
+    "openai",
+    "anthropic",
+    "gemini"
+  ],
+  "author": "Agentracer <hello@agentracer.dev>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/aqib-ilyas/agentracer-node"
+  },
+  "homepage": "https://agentracer.dev",
+  "bugs": {
+    "url": "https://github.com/aqib-ilyas/agentracer-node/issues"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^25.3.2",
+    "tsup": "^8.0.0",
+    "typescript": "^5.3.0",
+    "vitest": "^4.0.18"
+  },
+  "peerDependencies": {
+    "@anthropic-ai/sdk": ">=0.18.0",
+    "@google/generative-ai": ">=0.1.0",
+    "openai": ">=4.0.0"
+  },
+  "peerDependenciesMeta": {
+    "openai": {
+      "optional": true
+    },
+    "@anthropic-ai/sdk": {
+      "optional": true
+    },
+    "@google/generative-ai": {
+      "optional": true
+    }
+  }
+}