@ato-sdk/js 0.1.0

package/dist/openai.js

@@ -0,0 +1,360 @@
+"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, {
+  MODEL_PRICING: () => MODEL_PRICING,
+  calculateCost: () => calculateCost,
+  getClient: () => getClient,
+  init: () => init,
+  wrapOpenAI: () => wrapOpenAI
+});
+module.exports = __toCommonJS(openai_exports);
+
+// src/client.ts
+var SDK_VERSION = "0.1.0";
+var DEFAULT_ENDPOINT = "https://api.agentictool.ai";
+var DEFAULT_FLUSH_INTERVAL = 5e3;
+var DEFAULT_MAX_BATCH_SIZE = 50;
+var globalClient = null;
+var AtoClient = class {
+  constructor(config = {}) {
+    this.queue = [];
+    this.timer = null;
+    this.config = {
+      endpoint: DEFAULT_ENDPOINT,
+      batching: true,
+      flushInterval: DEFAULT_FLUSH_INTERVAL,
+      maxBatchSize: DEFAULT_MAX_BATCH_SIZE,
+      debug: false,
+      localOnly: false,
+      ...config
+    };
+    if (this.config.batching && !this.config.localOnly) {
+      this.timer = setInterval(() => this.flush(), this.config.flushInterval);
+      if (this.timer && typeof this.timer === "object" && "unref" in this.timer) {
+        this.timer.unref();
+      }
+    }
+  }
+  /**
+   * Record a trace
+   */
+  capture(trace) {
+    if (this.config.defaultTags) {
+      trace.tags = [...trace.tags || [], ...this.config.defaultTags];
+    }
+    if (this.config.defaultMetadata) {
+      trace.metadata = { ...this.config.defaultMetadata, ...trace.metadata };
+    }
+    if (this.config.sessionId && !trace.sessionId) {
+      trace.sessionId = this.config.sessionId;
+    }
+    if (this.config.userId && !trace.userId) {
+      trace.userId = this.config.userId;
+    }
+    if (this.config.debug) {
+      console.log("[ato]", JSON.stringify(trace, null, 2));
+    }
+    if (this.config.localOnly) return;
+    this.queue.push(trace);
+    if (!this.config.batching || this.queue.length >= this.config.maxBatchSize) {
+      this.flush();
+    }
+  }
+  /**
+   * Flush pending traces to ATO Cloud
+   */
+  async flush() {
+    if (this.queue.length === 0) return;
+    const traces = this.queue.splice(0);
+    const payload = {
+      traces,
+      sdk: "@ato/sdk",
+      sdkVersion: SDK_VERSION,
+      sentAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    try {
+      const headers = {
+        "Content-Type": "application/json"
+      };
+      if (this.config.apiKey) {
+        headers["Authorization"] = `Bearer ${this.config.apiKey}`;
+      }
+      const res = await fetch(`${this.config.endpoint}/api/analytics/ingest`, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(payload)
+      });
+      if (!res.ok && this.config.debug) {
+        console.error("[ato] Failed to send traces:", res.status, await res.text());
+      }
+    } catch (err) {
+      if (this.config.debug) {
+        console.error("[ato] Failed to send traces:", err);
+      }
+      this.queue.unshift(...traces);
+      if (this.queue.length > 1e3) {
+        this.queue.splice(0, this.queue.length - 500);
+      }
+    }
+  }
+  /**
+   * Shutdown — flush remaining traces
+   */
+  async shutdown() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    await this.flush();
+  }
+  getConfig() {
+    return { ...this.config };
+  }
+};
+function init(config = {}) {
+  globalClient = new AtoClient(config);
+  return globalClient;
+}
+function getClient() {
+  if (!globalClient) {
+    globalClient = new AtoClient();
+  }
+  return globalClient;
+}
+function generateTraceId() {
+  return `ato_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`;
+}
+
+// src/pricing.ts
+var MODEL_PRICING = {
+  // Anthropic
+  "claude-opus-4-6": { input: 15, output: 75, cached: 1.5 },
+  "claude-sonnet-4-6": { input: 3, output: 15, cached: 0.3 },
+  "claude-haiku-4-5": { input: 0.8, output: 4, cached: 0.08 },
+  "claude-sonnet-4-5": { input: 3, output: 15, cached: 0.3 },
+  "claude-3-5-sonnet": { input: 3, output: 15, cached: 0.3 },
+  "claude-3-5-haiku": { input: 0.8, output: 4, cached: 0.08 },
+  "claude-3-opus": { input: 15, output: 75, cached: 1.5 },
+  "claude-3-sonnet": { input: 3, output: 15 },
+  "claude-3-haiku": { input: 0.25, output: 1.25 },
+  // OpenAI
+  "gpt-4o": { input: 2.5, output: 10, cached: 1.25 },
+  "gpt-4o-mini": { input: 0.15, output: 0.6, cached: 0.075 },
+  "gpt-4-turbo": { input: 10, output: 30 },
+  "gpt-4": { input: 30, output: 60 },
+  "gpt-3.5-turbo": { input: 0.5, output: 1.5 },
+  "o1": { input: 15, output: 60, cached: 7.5 },
+  "o1-mini": { input: 3, output: 12, cached: 1.5 },
+  "o1-pro": { input: 150, output: 600 },
+  "o3": { input: 10, output: 40, cached: 2.5 },
+  "o3-mini": { input: 1.1, output: 4.4, cached: 0.55 },
+  "o4-mini": { input: 1.1, output: 4.4, cached: 0.275 },
+  "gpt-4.1": { input: 2, output: 8, cached: 0.5 },
+  "gpt-4.1-mini": { input: 0.4, output: 1.6, cached: 0.1 },
+  "gpt-4.1-nano": { input: 0.1, output: 0.4, cached: 0.025 },
+  // Google
+  "gemini-2.5-pro": { input: 1.25, output: 10 },
+  "gemini-2.5-flash": { input: 0.15, output: 0.6 },
+  "gemini-2.0-flash": { input: 0.1, output: 0.4 },
+  "gemini-1.5-pro": { input: 1.25, output: 5 },
+  "gemini-1.5-flash": { input: 0.075, output: 0.3 },
+  // Mistral
+  "mistral-large": { input: 2, output: 6 },
+  "mistral-small": { input: 0.2, output: 0.6 },
+  "codestral": { input: 0.3, output: 0.9 },
+  // Groq (inference pricing)
+  "llama-3.3-70b": { input: 0.59, output: 0.79 },
+  "llama-3.1-8b": { input: 0.05, output: 0.08 },
+  "mixtral-8x7b": { input: 0.24, output: 0.24 },
+  // Cohere
+  "command-r-plus": { input: 2.5, output: 10 },
+  "command-r": { input: 0.15, output: 0.6 }
+};
+function calculateCost(model, inputTokens, outputTokens, cachedTokens = 0) {
+  const pricing = MODEL_PRICING[model] || Object.entries(MODEL_PRICING).find(
+    ([key]) => model.startsWith(key)
+  )?.[1];
+  if (!pricing) return 0;
+  const inputCost = (inputTokens - cachedTokens) / 1e6 * pricing.input;
+  const outputCost = outputTokens / 1e6 * pricing.output;
+  const cachedCost = pricing.cached ? cachedTokens / 1e6 * pricing.cached : 0;
+  return inputCost + outputCost + cachedCost;
+}
+
+// src/openai.ts
+function wrapOpenAI(client) {
+  const originalCreate = client.chat.completions.create.bind(client.chat.completions);
+  client.chat.completions.create = async function(...args) {
+    const params = args[0] || {};
+    const start = Date.now();
+    if (params.stream) {
+      return handleStream(originalCreate, params, args, start);
+    }
+    try {
+      const result = await originalCreate(...args);
+      const duration = Date.now() - start;
+      const inputTokens = result.usage?.prompt_tokens || 0;
+      const outputTokens = result.usage?.completion_tokens || 0;
+      const cachedTokens = result.usage?.prompt_tokens_details?.cached_tokens || 0;
+      const trace = {
+        id: generateTraceId(),
+        provider: "openai",
+        model: result.model || params.model || "unknown",
+        inputTokens,
+        outputTokens,
+        cachedTokens,
+        totalTokens: inputTokens + outputTokens,
+        costUsd: calculateCost(result.model || params.model, inputTokens, outputTokens, cachedTokens),
+        durationMs: duration,
+        status: "success",
+        metadata: {
+          finishReason: result.choices?.[0]?.finish_reason,
+          maxTokens: params.max_tokens || params.max_completion_tokens,
+          temperature: params.temperature,
+          toolCalls: result.choices?.[0]?.message?.tool_calls?.length,
+          systemFingerprint: result.system_fingerprint
+        },
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      getClient().capture(trace);
+      return result;
+    } catch (err) {
+      const duration = Date.now() - start;
+      const trace = {
+        id: generateTraceId(),
+        provider: "openai",
+        model: params.model || "unknown",
+        inputTokens: 0,
+        outputTokens: 0,
+        cachedTokens: 0,
+        totalTokens: 0,
+        costUsd: 0,
+        durationMs: duration,
+        status: "error",
+        error: err.message || String(err),
+        metadata: {
+          errorType: err.constructor?.name,
+          statusCode: err.status,
+          errorCode: err.code
+        },
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      getClient().capture(trace);
+      throw err;
+    }
+  };
+  if (client.responses?.create) {
+    const originalResponses = client.responses.create.bind(client.responses);
+    client.responses.create = async function(...args) {
+      const params = args[0] || {};
+      const start = Date.now();
+      try {
+        const result = await originalResponses(...args);
+        const duration = Date.now() - start;
+        const inputTokens = result.usage?.input_tokens || 0;
+        const outputTokens = result.usage?.output_tokens || 0;
+        const trace = {
+          id: generateTraceId(),
+          provider: "openai",
+          model: result.model || params.model || "unknown",
+          inputTokens,
+          outputTokens,
+          cachedTokens: 0,
+          totalTokens: inputTokens + outputTokens,
+          costUsd: calculateCost(result.model || params.model, inputTokens, outputTokens),
+          durationMs: duration,
+          status: "success",
+          metadata: { api: "responses" },
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        getClient().capture(trace);
+        return result;
+      } catch (err) {
+        const duration = Date.now() - start;
+        getClient().capture({
+          id: generateTraceId(),
+          provider: "openai",
+          model: params.model || "unknown",
+          inputTokens: 0,
+          outputTokens: 0,
+          cachedTokens: 0,
+          totalTokens: 0,
+          costUsd: 0,
+          durationMs: duration,
+          status: "error",
+          error: err.message || String(err),
+          metadata: { api: "responses", errorType: err.constructor?.name },
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        throw err;
+      }
+    };
+  }
+  return client;
+}
+async function handleStream(originalCreate, params, args, start) {
+  const result = await originalCreate(...args);
+  if (result && Symbol.asyncIterator in result) {
+    const originalIterator = result[Symbol.asyncIterator].bind(result);
+    let totalInputTokens = 0;
+    let totalOutputTokens = 0;
+    let model = params.model || "unknown";
+    let finishReason = "";
+    result[Symbol.asyncIterator] = async function* () {
+      for await (const chunk of originalIterator()) {
+        if (chunk.usage) {
+          totalInputTokens = chunk.usage.prompt_tokens || 0;
+          totalOutputTokens = chunk.usage.completion_tokens || 0;
+        }
+        if (chunk.model) model = chunk.model;
+        if (chunk.choices?.[0]?.finish_reason) {
+          finishReason = chunk.choices[0].finish_reason;
+        }
+        yield chunk;
+      }
+      const duration = Date.now() - start;
+      getClient().capture({
+        id: generateTraceId(),
+        provider: "openai",
+        model,
+        inputTokens: totalInputTokens,
+        outputTokens: totalOutputTokens,
+        cachedTokens: 0,
+        totalTokens: totalInputTokens + totalOutputTokens,
+        costUsd: calculateCost(model, totalInputTokens, totalOutputTokens),
+        durationMs: duration,
+        status: "success",
+        metadata: { streaming: true, finishReason },
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    };
+  }
+  return result;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MODEL_PRICING,
+  calculateCost,
+  getClient,
+  init,
+  wrapOpenAI
+});

package/dist/openai.mjs

@@ -0,0 +1,165 @@
+import {
+  MODEL_PRICING,
+  calculateCost,
+  generateTraceId,
+  getClient,
+  init
+} from "./chunk-Q2LJUUHK.mjs";
+
+// src/openai.ts
+function wrapOpenAI(client) {
+  const originalCreate = client.chat.completions.create.bind(client.chat.completions);
+  client.chat.completions.create = async function(...args) {
+    const params = args[0] || {};
+    const start = Date.now();
+    if (params.stream) {
+      return handleStream(originalCreate, params, args, start);
+    }
+    try {
+      const result = await originalCreate(...args);
+      const duration = Date.now() - start;
+      const inputTokens = result.usage?.prompt_tokens || 0;
+      const outputTokens = result.usage?.completion_tokens || 0;
+      const cachedTokens = result.usage?.prompt_tokens_details?.cached_tokens || 0;
+      const trace = {
+        id: generateTraceId(),
+        provider: "openai",
+        model: result.model || params.model || "unknown",
+        inputTokens,
+        outputTokens,
+        cachedTokens,
+        totalTokens: inputTokens + outputTokens,
+        costUsd: calculateCost(result.model || params.model, inputTokens, outputTokens, cachedTokens),
+        durationMs: duration,
+        status: "success",
+        metadata: {
+          finishReason: result.choices?.[0]?.finish_reason,
+          maxTokens: params.max_tokens || params.max_completion_tokens,
+          temperature: params.temperature,
+          toolCalls: result.choices?.[0]?.message?.tool_calls?.length,
+          systemFingerprint: result.system_fingerprint
+        },
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      getClient().capture(trace);
+      return result;
+    } catch (err) {
+      const duration = Date.now() - start;
+      const trace = {
+        id: generateTraceId(),
+        provider: "openai",
+        model: params.model || "unknown",
+        inputTokens: 0,
+        outputTokens: 0,
+        cachedTokens: 0,
+        totalTokens: 0,
+        costUsd: 0,
+        durationMs: duration,
+        status: "error",
+        error: err.message || String(err),
+        metadata: {
+          errorType: err.constructor?.name,
+          statusCode: err.status,
+          errorCode: err.code
+        },
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      getClient().capture(trace);
+      throw err;
+    }
+  };
+  if (client.responses?.create) {
+    const originalResponses = client.responses.create.bind(client.responses);
+    client.responses.create = async function(...args) {
+      const params = args[0] || {};
+      const start = Date.now();
+      try {
+        const result = await originalResponses(...args);
+        const duration = Date.now() - start;
+        const inputTokens = result.usage?.input_tokens || 0;
+        const outputTokens = result.usage?.output_tokens || 0;
+        const trace = {
+          id: generateTraceId(),
+          provider: "openai",
+          model: result.model || params.model || "unknown",
+          inputTokens,
+          outputTokens,
+          cachedTokens: 0,
+          totalTokens: inputTokens + outputTokens,
+          costUsd: calculateCost(result.model || params.model, inputTokens, outputTokens),
+          durationMs: duration,
+          status: "success",
+          metadata: { api: "responses" },
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        getClient().capture(trace);
+        return result;
+      } catch (err) {
+        const duration = Date.now() - start;
+        getClient().capture({
+          id: generateTraceId(),
+          provider: "openai",
+          model: params.model || "unknown",
+          inputTokens: 0,
+          outputTokens: 0,
+          cachedTokens: 0,
+          totalTokens: 0,
+          costUsd: 0,
+          durationMs: duration,
+          status: "error",
+          error: err.message || String(err),
+          metadata: { api: "responses", errorType: err.constructor?.name },
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        throw err;
+      }
+    };
+  }
+  return client;
+}
+async function handleStream(originalCreate, params, args, start) {
+  const result = await originalCreate(...args);
+  if (result && Symbol.asyncIterator in result) {
+    const originalIterator = result[Symbol.asyncIterator].bind(result);
+    let totalInputTokens = 0;
+    let totalOutputTokens = 0;
+    let model = params.model || "unknown";
+    let finishReason = "";
+    result[Symbol.asyncIterator] = async function* () {
+      for await (const chunk of originalIterator()) {
+        if (chunk.usage) {
+          totalInputTokens = chunk.usage.prompt_tokens || 0;
+          totalOutputTokens = chunk.usage.completion_tokens || 0;
+        }
+        if (chunk.model) model = chunk.model;
+        if (chunk.choices?.[0]?.finish_reason) {
+          finishReason = chunk.choices[0].finish_reason;
+        }
+        yield chunk;
+      }
+      const duration = Date.now() - start;
+      getClient().capture({
+        id: generateTraceId(),
+        provider: "openai",
+        model,
+        inputTokens: totalInputTokens,
+        outputTokens: totalOutputTokens,
+        cachedTokens: 0,
+        totalTokens: totalInputTokens + totalOutputTokens,
+        costUsd: calculateCost(model, totalInputTokens, totalOutputTokens),
+        durationMs: duration,
+        status: "success",
+        metadata: { streaming: true, finishReason },
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    };
+  }
+  return result;
+}
+export {
+  MODEL_PRICING,
+  calculateCost,
+  getClient,
+  init,
+  wrapOpenAI
+};

package/dist/pricing-DnUk84wO.d.mts

@@ -0,0 +1,104 @@
+/**
+ * Core types for ATO SDK traces
+ */
+interface AtoTrace {
+    id: string;
+    provider: string;
+    model: string;
+    inputTokens: number;
+    outputTokens: number;
+    cachedTokens: number;
+    totalTokens: number;
+    costUsd: number;
+    durationMs: number;
+    status: 'success' | 'error';
+    error?: string;
+    metadata: Record<string, unknown>;
+    timestamp: string;
+    sessionId?: string;
+    userId?: string;
+    tags?: string[];
+}
+interface AtoConfig {
+    /** ATO Cloud API key (from app.agentictool.ai/settings) */
+    apiKey?: string;
+    /** ATO Cloud endpoint (default: https://api.agentictool.ai) */
+    endpoint?: string;
+    /** Send traces in batches for performance (default: true) */
+    batching?: boolean;
+    /** Batch flush interval in ms (default: 5000) */
+    flushInterval?: number;
+    /** Max batch size before auto-flush (default: 50) */
+    maxBatchSize?: number;
+    /** Log traces to console for debugging (default: false) */
+    debug?: boolean;
+    /** Default tags applied to all traces */
+    defaultTags?: string[];
+    /** Default metadata applied to all traces */
+    defaultMetadata?: Record<string, unknown>;
+    /** Session ID for grouping traces */
+    sessionId?: string;
+    /** User ID for attribution */
+    userId?: string;
+    /** Disable sending to cloud (local logging only) */
+    localOnly?: boolean;
+}
+interface BatchPayload {
+    traces: AtoTrace[];
+    sdk: string;
+    sdkVersion: string;
+    sentAt: string;
+}
+
+/**
+ * ATO Client — manages trace collection and cloud sync
+ */
+
+declare class AtoClient {
+    private config;
+    private queue;
+    private timer;
+    constructor(config?: AtoConfig);
+    /**
+     * Record a trace
+     */
+    capture(trace: AtoTrace): void;
+    /**
+     * Flush pending traces to ATO Cloud
+     */
+    flush(): Promise<void>;
+    /**
+     * Shutdown — flush remaining traces
+     */
+    shutdown(): Promise<void>;
+    getConfig(): AtoConfig;
+}
+/**
+ * Initialize the global ATO client
+ */
+declare function init(config?: AtoConfig): AtoClient;
+/**
+ * Get or create the global client
+ */
+declare function getClient(): AtoClient;
+/**
+ * Generate a unique trace ID
+ */
+declare function generateTraceId(): string;
+
+/**
+ * LLM model pricing (per 1M tokens)
+ * Updated: April 2026
+ */
+interface ModelPricing {
+    input: number;
+    output: number;
+    cached?: number;
+}
+declare const MODEL_PRICING: Record<string, ModelPricing>;
+/**
+ * Calculate cost for a given model and token usage
+ */
+declare function calculateCost(model: string, inputTokens: number, outputTokens: number, cachedTokens?: number): number;
+
+export { type AtoConfig as A, type BatchPayload as B, MODEL_PRICING as M, type AtoTrace as a, AtoClient as b, calculateCost as c, type ModelPricing as d, generateTraceId as e, getClient as g, init as i };