agentracer 0.1.0

package/dist/anthropic.js

@@ -0,0 +1,219 @@
+"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/anthropic.ts
+var anthropic_exports = {};
+__export(anthropic_exports, {
+  TrackedAnthropic: () => TrackedAnthropic,
+  _setClientForTesting: () => _setClientForTesting,
+  anthropic: () => anthropic
+});
+module.exports = __toCommonJS(anthropic_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/anthropic.ts
+var _clientInstance = null;
+function getClient(opts) {
+  if (opts) {
+    const Anthropic = require("@anthropic-ai/sdk").default || require("@anthropic-ai/sdk");
+    return new Anthropic(opts);
+  }
+  if (!_clientInstance) {
+    const Anthropic = require("@anthropic-ai/sdk").default || require("@anthropic-ai/sdk");
+    _clientInstance = new Anthropic();
+  }
+  return _clientInstance;
+}
+function _setClientForTesting(client) {
+  _clientInstance = client;
+}
+async function* wrapAnthropicStream(stream, model, featureTag, start) {
+  let inputTokens = 0;
+  let outputTokens = 0;
+  for await (const event of stream) {
+    if (event.type === "message_start" && event.message?.usage) {
+      inputTokens = event.message.usage.input_tokens ?? 0;
+    }
+    if (event.type === "message_delta" && event.usage) {
+      outputTokens = event.usage.output_tokens ?? 0;
+    }
+    yield event;
+  }
+  track({
+    model,
+    inputTokens,
+    outputTokens,
+    latencyMs: Date.now() - start,
+    featureTag,
+    provider: "anthropic"
+  }).catch(() => {
+  });
+}
+function createAnthropicProxy(clientGetter) {
+  return new Proxy({}, {
+    get(_, prop) {
+      if (prop === "messages") {
+        return {
+          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) {
+              const stream = await client.messages.create(cleanParams);
+              return wrapAnthropicStream(stream, params.model, featureTag, start);
+            }
+            let response;
+            try {
+              response = await client.messages.create(cleanParams);
+            } catch (err) {
+              track({
+                model: params.model,
+                inputTokens: 0,
+                outputTokens: 0,
+                latencyMs: Date.now() - start,
+                featureTag,
+                provider: "anthropic",
+                success: false,
+                errorType: err?.constructor?.name ?? "Error"
+              }).catch(() => {
+              });
+              throw err;
+            }
+            track({
+              model: params.model,
+              inputTokens: response.usage?.input_tokens ?? 0,
+              outputTokens: response.usage?.output_tokens ?? 0,
+              cachedTokens: response.usage?.cache_read_input_tokens ?? 0,
+              latencyMs: Date.now() - start,
+              featureTag,
+              provider: "anthropic"
+            }).catch(() => {
+            });
+            return response;
+          }
+        };
+      }
+      return clientGetter()[prop];
+    }
+  });
+}
+var TrackedAnthropic = class {
+  constructor(options) {
+    const Anthropic = require("@anthropic-ai/sdk").default || require("@anthropic-ai/sdk");
+    const client = new Anthropic(options);
+    this._proxy = createAnthropicProxy(() => client);
+  }
+  get messages() {
+    return this._proxy.messages;
+  }
+};
+var anthropic = createAnthropicProxy(() => getClient());
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TrackedAnthropic,
+  _setClientForTesting,
+  anthropic
+});

package/dist/anthropic.mjs

@@ -0,0 +1,109 @@
+import {
+  __require,
+  featureTagStorage,
+  track
+} from "./chunk-72GBZ4TW.mjs";
+
+// src/anthropic.ts
+var _clientInstance = null;
+function getClient(opts) {
+  if (opts) {
+    const Anthropic = __require("@anthropic-ai/sdk").default || __require("@anthropic-ai/sdk");
+    return new Anthropic(opts);
+  }
+  if (!_clientInstance) {
+    const Anthropic = __require("@anthropic-ai/sdk").default || __require("@anthropic-ai/sdk");
+    _clientInstance = new Anthropic();
+  }
+  return _clientInstance;
+}
+function _setClientForTesting(client) {
+  _clientInstance = client;
+}
+async function* wrapAnthropicStream(stream, model, featureTag, start) {
+  let inputTokens = 0;
+  let outputTokens = 0;
+  for await (const event of stream) {
+    if (event.type === "message_start" && event.message?.usage) {
+      inputTokens = event.message.usage.input_tokens ?? 0;
+    }
+    if (event.type === "message_delta" && event.usage) {
+      outputTokens = event.usage.output_tokens ?? 0;
+    }
+    yield event;
+  }
+  track({
+    model,
+    inputTokens,
+    outputTokens,
+    latencyMs: Date.now() - start,
+    featureTag,
+    provider: "anthropic"
+  }).catch(() => {
+  });
+}
+function createAnthropicProxy(clientGetter) {
+  return new Proxy({}, {
+    get(_, prop) {
+      if (prop === "messages") {
+        return {
+          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) {
+              const stream = await client.messages.create(cleanParams);
+              return wrapAnthropicStream(stream, params.model, featureTag, start);
+            }
+            let response;
+            try {
+              response = await client.messages.create(cleanParams);
+            } catch (err) {
+              track({
+                model: params.model,
+                inputTokens: 0,
+                outputTokens: 0,
+                latencyMs: Date.now() - start,
+                featureTag,
+                provider: "anthropic",
+                success: false,
+                errorType: err?.constructor?.name ?? "Error"
+              }).catch(() => {
+              });
+              throw err;
+            }
+            track({
+              model: params.model,
+              inputTokens: response.usage?.input_tokens ?? 0,
+              outputTokens: response.usage?.output_tokens ?? 0,
+              cachedTokens: response.usage?.cache_read_input_tokens ?? 0,
+              latencyMs: Date.now() - start,
+              featureTag,
+              provider: "anthropic"
+            }).catch(() => {
+            });
+            return response;
+          }
+        };
+      }
+      return clientGetter()[prop];
+    }
+  });
+}
+var TrackedAnthropic = class {
+  constructor(options) {
+    const Anthropic = __require("@anthropic-ai/sdk").default || __require("@anthropic-ai/sdk");
+    const client = new Anthropic(options);
+    this._proxy = createAnthropicProxy(() => client);
+  }
+  get messages() {
+    return this._proxy.messages;
+  }
+};
+var anthropic = createAnthropicProxy(() => getClient());
+export {
+  TrackedAnthropic,
+  _setClientForTesting,
+  anthropic
+};

package/dist/chunk-72GBZ4TW.mjs

@@ -0,0 +1,160 @@
+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
+import { AsyncLocalStorage } from "async_hooks";
+import { randomUUID } from "crypto";
+var config = {
+  trackerApiKey: "",
+  projectId: "",
+  environment: "production",
+  host: "https://api.agentracer.dev",
+  debug: false,
+  enabled: true
+};
+var featureTagStorage = new AsyncLocalStorage();
+var runStorage = new AsyncLocalStorage();
+function init(options) {
+  config = { ...config, ...options };
+}
+function getConfig() {
+  return config;
+}
+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 {
+  }
+}
+function observe(fn, options) {
+  return ((...args) => featureTagStorage.run(options.featureTag, () => fn(...args)));
+}
+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 {
+  }
+}
+var AgentRun = class {
+  constructor(options = {}) {
+    this.stepCounter = 0;
+    this.runId = options.runId ?? randomUUID();
+    this.runName = options.runName;
+    this.featureTag = options.featureTag ?? "unknown";
+    this.endUserId = options.endUserId;
+  }
+  /** @internal */
+  _nextStep() {
+    return ++this.stepCounter;
+  }
+  async execute(fn) {
+    sendRunApi("/api/runs/start", {
+      project_id: config.projectId,
+      run_id: this.runId,
+      run_name: this.runName,
+      feature_tag: this.featureTag,
+      end_user_id: this.endUserId
+    }).catch(() => {
+    });
+    try {
+      const result = await runStorage.run(
+        this,
+        () => featureTagStorage.run(this.featureTag, fn)
+      );
+      sendRunApi("/api/runs/end", {
+        project_id: config.projectId,
+        run_id: this.runId,
+        status: "completed"
+      }).catch(() => {
+      });
+      return result;
+    } catch (err) {
+      sendRunApi("/api/runs/end", {
+        project_id: config.projectId,
+        run_id: this.runId,
+        status: "failed",
+        error_type: err?.constructor?.name ?? "Error"
+      }).catch(() => {
+      });
+      throw err;
+    }
+  }
+};
+
+export {
+  __require,
+  featureTagStorage,
+  runStorage,
+  init,
+  getConfig,
+  sendTelemetry,
+  observe,
+  track,
+  AgentRun
+};

package/dist/chunk-HCE5ELLK.mjs

@@ -0,0 +1,66 @@
+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
+import { AsyncLocalStorage } from "async_hooks";
+var config = {
+  trackerApiKey: "",
+  projectId: "",
+  environment: "production",
+  host: "https://api.agentracer.dev",
+  debug: false,
+  enabled: true
+};
+var featureTagStorage = new AsyncLocalStorage();
+function init(options) {
+  config = { ...config, ...options };
+}
+function getConfig() {
+  return config;
+}
+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 {
+  }
+}
+function observe(fn, options) {
+  return ((...args) => featureTagStorage.run(options.featureTag, () => fn(...args)));
+}
+async function track(options) {
+  const currentTag = featureTagStorage.getStore();
+  await sendTelemetry({
+    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,
+    latency_ms: options.latencyMs,
+    environment: options.environment ?? config.environment
+  });
+}
+
+export {
+  __require,
+  featureTagStorage,
+  init,
+  getConfig,
+  sendTelemetry,
+  observe,
+  track
+};

package/dist/gemini.d.mts

@@ -0,0 +1,5 @@
+/** @internal Test-only: inject a mock client */
+declare function _setClientForTesting(client: any): void;
+declare const gemini: any;
+
+export { _setClientForTesting, gemini };

package/dist/gemini.d.ts

@@ -0,0 +1,5 @@
+/** @internal Test-only: inject a mock client */
+declare function _setClientForTesting(client: any): void;
+declare const gemini: any;
+
+export { _setClientForTesting, gemini };