@ato-sdk/js 0.1.0

package/README.md

@@ -0,0 +1,116 @@
+# @agentic-tool-optimization/sdk
+
+Auto-capture LLM traces for [ATO](https://agentictool.ai). Works with Anthropic, OpenAI, and any LLM provider.
+
+## Install
+
+```bash
+npm install @agentic-tool-optimization/sdk
+```
+
+## Quick Start
+
+```typescript
+import { init } from '@agentic-tool-optimization/sdk';
+
+// Initialize with your ATO API key
+init({ apiKey: 'your-ato-api-key' });
+```
+
+### Anthropic
+
+```typescript
+import Anthropic from '@anthropic-ai/sdk';
+import { wrapAnthropic } from '@agentic-tool-optimization/sdk/anthropic';
+
+const client = wrapAnthropic(new Anthropic());
+
+// All calls are now auto-traced — no other changes needed
+const msg = await client.messages.create({
+  model: 'claude-sonnet-4-6',
+  max_tokens: 1024,
+  messages: [{ role: 'user', content: 'Hello' }],
+});
+```
+
+### OpenAI
+
+```typescript
+import OpenAI from 'openai';
+import { wrapOpenAI } from '@agentic-tool-optimization/sdk/openai';
+
+const client = wrapOpenAI(new OpenAI());
+
+// All calls are now auto-traced
+const res = await client.chat.completions.create({
+  model: 'gpt-4o',
+  messages: [{ role: 'user', content: 'Hello' }],
+});
+```
+
+## What Gets Captured
+
+Every LLM call automatically records:
+
+- **Model** — which model was used
+- **Tokens** — input, output, cached
+- **Cost** — calculated from built-in pricing table (60+ models)
+- **Duration** — response time in ms
+- **Status** — success or error (with error message)
+- **Metadata** — temperature, max_tokens, tool usage, stop reason
+
+## Configuration
+
+```typescript
+init({
+  apiKey: 'your-key',                    // ATO Cloud API key
+  endpoint: 'https://api.agentictool.ai', // Custom endpoint
+  debug: true,                            // Log traces to console
+  batching: true,                         // Batch traces (default)
+  flushInterval: 5000,                    // Flush every 5s (default)
+  maxBatchSize: 50,                       // Flush at 50 traces (default)
+  sessionId: 'my-session',               // Group traces by session
+  userId: 'user-123',                    // Attribute traces to user
+  defaultTags: ['production'],           // Tags for all traces
+  localOnly: true,                       // Don't send to cloud
+});
+```
+
+## Manual Traces
+
+For custom LLM providers:
+
+```typescript
+import { capture, generateTraceId } from '@agentic-tool-optimization/sdk';
+import { calculateCost } from '@agentic-tool-optimization/sdk';
+
+capture({
+  id: generateTraceId(),
+  provider: 'custom',
+  model: 'my-model',
+  inputTokens: 100,
+  outputTokens: 50,
+  cachedTokens: 0,
+  totalTokens: 150,
+  costUsd: calculateCost('gpt-4o', 100, 50),
+  durationMs: 234,
+  status: 'success',
+  metadata: {},
+  timestamp: new Date().toISOString(),
+});
+```
+
+## Cost Calculation
+
+Built-in pricing for 60+ models:
+
+```typescript
+import { calculateCost } from '@agentic-tool-optimization/sdk';
+
+calculateCost('claude-sonnet-4-6', 1000, 500);  // $0.0105
+calculateCost('gpt-4o', 1000, 500);             // $0.0075
+```
+
+## License
+
+MIT

package/dist/anthropic.d.mts

@@ -0,0 +1,26 @@
+export { A as AtoConfig, a as AtoTrace, M as MODEL_PRICING, c as calculateCost, g as getClient, i as init } from './pricing-DnUk84wO.mjs';
+
+/**
+ * ATO wrapper for the Anthropic SDK
+ *
+ * Usage:
+ *   import Anthropic from '@anthropic-ai/sdk';
+ *   import { wrapAnthropic } from '@ato/sdk/anthropic';
+ *
+ *   const client = wrapAnthropic(new Anthropic());
+ *   // All calls are now auto-traced
+ *   const msg = await client.messages.create({ model: 'claude-sonnet-4-6', ... });
+ */
+type AnthropicClient = {
+    messages: {
+        create: (...args: any[]) => Promise<any>;
+        stream: (...args: any[]) => any;
+    };
+    [key: string]: any;
+};
+/**
+ * Wrap an Anthropic client to auto-capture traces
+ */
+declare function wrapAnthropic<T extends AnthropicClient>(client: T): T;
+
+export { wrapAnthropic };

package/dist/anthropic.d.ts

@@ -0,0 +1,26 @@
+export { A as AtoConfig, a as AtoTrace, M as MODEL_PRICING, c as calculateCost, g as getClient, i as init } from './pricing-DnUk84wO.js';
+
+/**
+ * ATO wrapper for the Anthropic SDK
+ *
+ * Usage:
+ *   import Anthropic from '@anthropic-ai/sdk';
+ *   import { wrapAnthropic } from '@ato/sdk/anthropic';
+ *
+ *   const client = wrapAnthropic(new Anthropic());
+ *   // All calls are now auto-traced
+ *   const msg = await client.messages.create({ model: 'claude-sonnet-4-6', ... });
+ */
+type AnthropicClient = {
+    messages: {
+        create: (...args: any[]) => Promise<any>;
+        stream: (...args: any[]) => any;
+    };
+    [key: string]: any;
+};
+/**
+ * Wrap an Anthropic client to auto-capture traces
+ */
+declare function wrapAnthropic<T extends AnthropicClient>(client: T): T;
+
+export { wrapAnthropic };

package/dist/anthropic.js

@@ -0,0 +1,310 @@
+"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, {
+  MODEL_PRICING: () => MODEL_PRICING,
+  calculateCost: () => calculateCost,
+  getClient: () => getClient,
+  init: () => init,
+  wrapAnthropic: () => wrapAnthropic
+});
+module.exports = __toCommonJS(anthropic_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/anthropic.ts
+function wrapAnthropic(client) {
+  const originalCreate = client.messages.create.bind(client.messages);
+  const originalStream = client.messages.stream?.bind(client.messages);
+  client.messages.create = async function(...args) {
+    const params = args[0] || {};
+    const start = Date.now();
+    let trace;
+    try {
+      const result = await originalCreate(...args);
+      const duration = Date.now() - start;
+      const inputTokens = result.usage?.input_tokens || 0;
+      const outputTokens = result.usage?.output_tokens || 0;
+      const cachedTokens = result.usage?.cache_read_input_tokens || 0;
+      trace = {
+        id: generateTraceId(),
+        provider: "anthropic",
+        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: {
+          stopReason: result.stop_reason,
+          maxTokens: params.max_tokens,
+          temperature: params.temperature,
+          system: params.system ? "[present]" : void 0,
+          toolUse: params.tools?.length ? params.tools.length : void 0
+        },
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      getClient().capture(trace);
+      return result;
+    } catch (err) {
+      const duration = Date.now() - start;
+      trace = {
+        id: generateTraceId(),
+        provider: "anthropic",
+        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
+        },
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      getClient().capture(trace);
+      throw err;
+    }
+  };
+  if (originalStream) {
+    client.messages.stream = function(...args) {
+      const params = args[0] || {};
+      const start = Date.now();
+      const stream = originalStream(...args);
+      const originalOn = stream.on?.bind(stream);
+      if (originalOn) {
+        stream.on = function(event, handler) {
+          if (event === "finalMessage" || event === "message") {
+            const wrappedHandler = (message) => {
+              const duration = Date.now() - start;
+              const inputTokens = message.usage?.input_tokens || 0;
+              const outputTokens = message.usage?.output_tokens || 0;
+              const cachedTokens = message.usage?.cache_read_input_tokens || 0;
+              getClient().capture({
+                id: generateTraceId(),
+                provider: "anthropic",
+                model: message.model || params.model || "unknown",
+                inputTokens,
+                outputTokens,
+                cachedTokens,
+                totalTokens: inputTokens + outputTokens,
+                costUsd: calculateCost(message.model || params.model, inputTokens, outputTokens, cachedTokens),
+                durationMs: duration,
+                status: "success",
+                metadata: { streaming: true, stopReason: message.stop_reason },
+                timestamp: (/* @__PURE__ */ new Date()).toISOString()
+              });
+              handler(message);
+            };
+            return originalOn(event, wrappedHandler);
+          }
+          return originalOn(event, handler);
+        };
+      }
+      return stream;
+    };
+  }
+  return client;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MODEL_PRICING,
+  calculateCost,
+  getClient,
+  init,
+  wrapAnthropic
+});

package/dist/anthropic.mjs

@@ -0,0 +1,115 @@
+import {
+  MODEL_PRICING,
+  calculateCost,
+  generateTraceId,
+  getClient,
+  init
+} from "./chunk-Q2LJUUHK.mjs";
+
+// src/anthropic.ts
+function wrapAnthropic(client) {
+  const originalCreate = client.messages.create.bind(client.messages);
+  const originalStream = client.messages.stream?.bind(client.messages);
+  client.messages.create = async function(...args) {
+    const params = args[0] || {};
+    const start = Date.now();
+    let trace;
+    try {
+      const result = await originalCreate(...args);
+      const duration = Date.now() - start;
+      const inputTokens = result.usage?.input_tokens || 0;
+      const outputTokens = result.usage?.output_tokens || 0;
+      const cachedTokens = result.usage?.cache_read_input_tokens || 0;
+      trace = {
+        id: generateTraceId(),
+        provider: "anthropic",
+        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: {
+          stopReason: result.stop_reason,
+          maxTokens: params.max_tokens,
+          temperature: params.temperature,
+          system: params.system ? "[present]" : void 0,
+          toolUse: params.tools?.length ? params.tools.length : void 0
+        },
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      getClient().capture(trace);
+      return result;
+    } catch (err) {
+      const duration = Date.now() - start;
+      trace = {
+        id: generateTraceId(),
+        provider: "anthropic",
+        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
+        },
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      getClient().capture(trace);
+      throw err;
+    }
+  };
+  if (originalStream) {
+    client.messages.stream = function(...args) {
+      const params = args[0] || {};
+      const start = Date.now();
+      const stream = originalStream(...args);
+      const originalOn = stream.on?.bind(stream);
+      if (originalOn) {
+        stream.on = function(event, handler) {
+          if (event === "finalMessage" || event === "message") {
+            const wrappedHandler = (message) => {
+              const duration = Date.now() - start;
+              const inputTokens = message.usage?.input_tokens || 0;
+              const outputTokens = message.usage?.output_tokens || 0;
+              const cachedTokens = message.usage?.cache_read_input_tokens || 0;
+              getClient().capture({
+                id: generateTraceId(),
+                provider: "anthropic",
+                model: message.model || params.model || "unknown",
+                inputTokens,
+                outputTokens,
+                cachedTokens,
+                totalTokens: inputTokens + outputTokens,
+                costUsd: calculateCost(message.model || params.model, inputTokens, outputTokens, cachedTokens),
+                durationMs: duration,
+                status: "success",
+                metadata: { streaming: true, stopReason: message.stop_reason },
+                timestamp: (/* @__PURE__ */ new Date()).toISOString()
+              });
+              handler(message);
+            };
+            return originalOn(event, wrappedHandler);
+          }
+          return originalOn(event, handler);
+        };
+      }
+      return stream;
+    };
+  }
+  return client;
+}
+export {
+  MODEL_PRICING,
+  calculateCost,
+  getClient,
+  init,
+  wrapAnthropic
+};