@analytix402/sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,413 @@
+"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/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Analytix402: () => Analytix402,
+  analytix402: () => analytix402,
+  createAnalytix402Client: () => createAnalytix402Client,
+  createClient: () => createClient
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/client.ts
+var SDK_NAME = "@analytix402/sdk";
+var SDK_VERSION = "0.1.0";
+var DEFAULT_CONFIG = {
+  baseUrl: "https://api.analytix402.com",
+  debug: false,
+  batchSize: 100,
+  flushInterval: 5e3,
+  maxRetries: 3,
+  maxQueueSize: 1e3,
+  timeout: 1e4,
+  excludePaths: ["/health", "/healthz", "/ready", "/metrics", "/favicon.ico"]
+};
+function createClient(config) {
+  if (!config.apiKey) {
+    throw new Error("Analytix402: apiKey is required");
+  }
+  if (!config.apiKey.startsWith("ax_live_") && !config.apiKey.startsWith("ax_test_")) {
+    console.warn("Analytix402: API key should start with ax_live_ or ax_test_");
+  }
+  const cfg = {
+    ...DEFAULT_CONFIG,
+    ...config
+  };
+  const agentId = cfg.agentId;
+  const queue = [];
+  let flushTimer = null;
+  let isFlushing = false;
+  let isShutdown = false;
+  const log = (...args) => {
+    if (cfg.debug) {
+      console.log("[Analytix402]", ...args);
+    }
+  };
+  const warn = (...args) => {
+    console.warn("[Analytix402]", ...args);
+  };
+  function enqueue(event) {
+    if (isShutdown) {
+      warn("Client is shutdown, event dropped");
+      return;
+    }
+    if (queue.length >= cfg.maxQueueSize) {
+      warn(`Queue full (${cfg.maxQueueSize}), dropping oldest event`);
+      queue.shift();
+    }
+    queue.push({
+      event,
+      attempts: 0,
+      addedAt: Date.now()
+    });
+    log(`Event queued (${queue.length} in queue)`);
+    if (queue.length >= cfg.batchSize) {
+      log("Batch size reached, flushing");
+      flush();
+    } else if (!flushTimer) {
+      flushTimer = setTimeout(() => {
+        flushTimer = null;
+        flush();
+      }, cfg.flushInterval);
+    }
+  }
+  function track(event) {
+    if (agentId && !event.agentId) {
+      event.agentId = agentId;
+    }
+    enqueue(event);
+  }
+  function heartbeat(status = "healthy", metadata) {
+    if (!agentId) {
+      warn("heartbeat() requires agentId in config");
+      return;
+    }
+    const event = {
+      type: "heartbeat",
+      agentId,
+      status,
+      metadata,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    enqueue(event);
+  }
+  function reportOutcome(taskId, success, options) {
+    const event = {
+      type: "task_outcome",
+      agentId,
+      taskId,
+      success,
+      durationMs: options?.durationMs,
+      cost: options?.cost,
+      metadata: options?.metadata,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    enqueue(event);
+  }
+  function startTask(taskId) {
+    const id = taskId || `task_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`;
+    const startTime = Date.now();
+    return {
+      taskId: id,
+      end(success, metadata) {
+        const durationMs = Date.now() - startTime;
+        reportOutcome(id, success, { durationMs, metadata });
+      }
+    };
+  }
+  function trackLLM(usage) {
+    const event = {
+      type: "llm_usage",
+      agentId,
+      taskId: usage.taskId,
+      model: usage.model,
+      provider: usage.provider,
+      inputTokens: usage.inputTokens,
+      outputTokens: usage.outputTokens,
+      totalTokens: usage.inputTokens + usage.outputTokens,
+      costUsd: usage.costUsd,
+      durationMs: usage.durationMs,
+      metadata: usage.metadata,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    enqueue(event);
+  }
+  async function sendBatch(events) {
+    if (events.length === 0) return true;
+    const payload = {
+      events,
+      sdk: {
+        name: SDK_NAME,
+        version: SDK_VERSION
+      },
+      sentAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    try {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), cfg.timeout);
+      const response = await fetch(`${cfg.baseUrl}/api/ingest/batch`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "X-API-Key": cfg.apiKey,
+          "User-Agent": `${SDK_NAME}/${SDK_VERSION}`
+        },
+        body: JSON.stringify(payload),
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        const text = await response.text().catch(() => "Unknown error");
+        throw new Error(`HTTP ${response.status}: ${text}`);
+      }
+      log(`Sent ${events.length} events successfully`);
+      return true;
+    } catch (error) {
+      if (error instanceof Error && error.name === "AbortError") {
+        warn("Request timed out");
+      } else {
+        warn("Failed to send events:", error);
+      }
+      return false;
+    }
+  }
+  async function flush() {
+    if (isFlushing || queue.length === 0) {
+      return;
+    }
+    isFlushing = true;
+    if (flushTimer) {
+      clearTimeout(flushTimer);
+      flushTimer = null;
+    }
+    const batch = queue.splice(0, cfg.batchSize);
+    const events = batch.map((q) => q.event);
+    log(`Flushing ${events.length} events`);
+    const success = await sendBatch(events);
+    if (!success) {
+      const retriable = batch.filter((q) => q.attempts < cfg.maxRetries);
+      if (retriable.length > 0) {
+        log(`Re-queuing ${retriable.length} events for retry`);
+        for (const item of retriable.reverse()) {
+          item.attempts++;
+          queue.unshift(item);
+        }
+        const backoff = Math.min(1e3 * Math.pow(2, retriable[0].attempts), 3e4);
+        log(`Retry scheduled in ${backoff}ms`);
+        flushTimer = setTimeout(() => {
+          flushTimer = null;
+          flush();
+        }, backoff);
+      } else {
+        warn(`Dropped ${batch.length} events after ${cfg.maxRetries} retries`);
+      }
+    }
+    isFlushing = false;
+    if (queue.length > 0 && !flushTimer) {
+      flushTimer = setTimeout(() => {
+        flushTimer = null;
+        flush();
+      }, cfg.flushInterval);
+    }
+  }
+  async function shutdown() {
+    log("Shutting down...");
+    isShutdown = true;
+    if (flushTimer) {
+      clearTimeout(flushTimer);
+      flushTimer = null;
+    }
+    if (queue.length > 0) {
+      log(`Flushing ${queue.length} remaining events`);
+      isFlushing = false;
+      await flush();
+    }
+    log("Shutdown complete");
+  }
+  if (typeof process !== "undefined") {
+    const handleExit = () => {
+      shutdown().catch(console.error);
+    };
+    process.on("beforeExit", handleExit);
+    process.on("SIGINT", handleExit);
+    process.on("SIGTERM", handleExit);
+  }
+  return {
+    track,
+    flush,
+    shutdown,
+    heartbeat,
+    reportOutcome,
+    startTask,
+    trackLLM
+  };
+}
+
+// src/middleware.ts
+var X402_HEADERS = {
+  // Payment receipt header (contains payment proof)
+  PAYMENT: "x-payment",
+  // Payment token (JWT with payment info)
+  PAYMENT_TOKEN: "x-payment-token",
+  // Payer wallet address
+  PAYER: "x-payer",
+  // Payment amount
+  AMOUNT: "x-payment-amount",
+  // Payment currency
+  CURRENCY: "x-payment-currency",
+  // Transaction hash
+  TX_HASH: "x-payment-tx",
+  // Facilitator that processed payment
+  FACILITATOR: "x-facilitator"
+};
+var DEFAULT_EXCLUDE_PATHS = [
+  "/health",
+  "/healthz",
+  "/ready",
+  "/readyz",
+  "/live",
+  "/livez",
+  "/metrics",
+  "/favicon.ico",
+  "/.well-known"
+];
+function matchPath(path, pattern) {
+  if (pattern.includes("*")) {
+    const regex = new RegExp("^" + pattern.replace(/\*/g, ".*") + "$");
+    return regex.test(path);
+  }
+  return path === pattern || path.startsWith(pattern + "/");
+}
+function extractPaymentInfo(req) {
+  const paymentHeader = req.get(X402_HEADERS.PAYMENT) || req.get(X402_HEADERS.PAYMENT_TOKEN);
+  if (!paymentHeader) {
+    return void 0;
+  }
+  const wallet = req.get(X402_HEADERS.PAYER) || "";
+  const amount = req.get(X402_HEADERS.AMOUNT) || "0";
+  const currency = req.get(X402_HEADERS.CURRENCY) || "USDC";
+  const txHash = req.get(X402_HEADERS.TX_HASH);
+  const facilitator = req.get(X402_HEADERS.FACILITATOR);
+  return {
+    amount,
+    currency,
+    wallet,
+    status: "success",
+    // If we have payment header, assume success (verified by facilitator)
+    txHash: txHash || void 0,
+    facilitator: facilitator || void 0
+  };
+}
+function getHeader(req, name) {
+  const value = req.headers[name.toLowerCase()];
+  if (Array.isArray(value)) {
+    return value[0];
+  }
+  return value;
+}
+function analytix402(config) {
+  const client = createClient(config);
+  const excludePaths = [
+    ...DEFAULT_EXCLUDE_PATHS,
+    ...config.excludePaths || []
+  ];
+  const debug = config.debug || false;
+  const agentId = config.agentId;
+  const agentName = config.agentName;
+  const log = (...args) => {
+    if (debug) {
+      console.log("[Analytix402]", ...args);
+    }
+  };
+  return function middleware(req, res, next) {
+    const startTime = Date.now();
+    const path = req.path || req.url;
+    const isExcluded = excludePaths.some((pattern) => matchPath(path, pattern));
+    if (isExcluded) {
+      log(`Excluded path: ${path}`);
+      return next();
+    }
+    if (config.shouldTrack) {
+      const requestInfo = {
+        method: req.method,
+        path,
+        url: req.originalUrl || req.url,
+        headers: req.headers,
+        ip: req.ip
+      };
+      if (!config.shouldTrack(requestInfo)) {
+        log(`Skipped by shouldTrack: ${path}`);
+        return next();
+      }
+    }
+    res.on("finish", () => {
+      const responseTime = Date.now() - startTime;
+      const statusCode = res.statusCode;
+      const payment = extractPaymentInfo(req);
+      let endpoint = path;
+      if (config.getEndpointName) {
+        endpoint = config.getEndpointName({
+          method: req.method,
+          path,
+          url: req.originalUrl || req.url,
+          headers: req.headers,
+          ip: req.ip
+        });
+      }
+      const event = {
+        type: "request",
+        method: req.method,
+        path,
+        endpoint,
+        statusCode,
+        responseTimeMs: responseTime,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        ip: req.ip,
+        userAgent: getHeader(req, "user-agent")
+      };
+      if (agentId) {
+        event.agentId = agentId;
+      }
+      const taskId = getHeader(req, "x-task-id");
+      if (taskId) {
+        event.taskId = taskId;
+      }
+      if (payment) {
+        event.payment = payment;
+        log(`Payment captured: ${payment.amount} ${payment.currency} from ${payment.wallet}`);
+      }
+      client.track(event);
+      log(`Tracked: ${req.method} ${path} ${statusCode} ${responseTime}ms`);
+    });
+    next();
+  };
+}
+var Analytix402 = analytix402;
+function createAnalytix402Client(config) {
+  return createClient(config);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Analytix402,
+  analytix402,
+  createAnalytix402Client,
+  createClient
+});