@ato-sdk/js 0.1.0 → 0.2.0

package/README.md

@@ -1,17 +1,17 @@
-# @agentic-tool-optimization/sdk
+# @ato-sdk/js
 
 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
+npm install @ato-sdk/js
 ```
 
 ## Quick Start
 
 ```typescript
-import { init } from '@agentic-tool-optimization/sdk';
+import { init } from '@ato-sdk/js';
 
 // Initialize with your ATO API key
 init({ apiKey: 'your-ato-api-key' });
@@ -21,7 +21,7 @@ init({ apiKey: 'your-ato-api-key' });
 
 ```typescript
 import Anthropic from '@anthropic-ai/sdk';
-import { wrapAnthropic } from '@agentic-tool-optimization/sdk/anthropic';
+import { wrapAnthropic } from '@ato-sdk/js/anthropic';
 
 const client = wrapAnthropic(new Anthropic());
 
@@ -37,7 +37,7 @@ const msg = await client.messages.create({
 
 ```typescript
 import OpenAI from 'openai';
-import { wrapOpenAI } from '@agentic-tool-optimization/sdk/openai';
+import { wrapOpenAI } from '@ato-sdk/js/openai';
 
 const client = wrapOpenAI(new OpenAI());
 
@@ -81,8 +81,8 @@ init({
 For custom LLM providers:
 
 ```typescript
-import { capture, generateTraceId } from '@agentic-tool-optimization/sdk';
-import { calculateCost } from '@agentic-tool-optimization/sdk';
+import { capture, generateTraceId } from '@ato-sdk/js';
+import { calculateCost } from '@ato-sdk/js';
 
 capture({
   id: generateTraceId(),
@@ -105,7 +105,7 @@ capture({
 Built-in pricing for 60+ models:
 
 ```typescript
-import { calculateCost } from '@agentic-tool-optimization/sdk';
+import { calculateCost } from '@ato-sdk/js';
 
 calculateCost('claude-sonnet-4-6', 1000, 500);  // $0.0105
 calculateCost('gpt-4o', 1000, 500);             // $0.0075

package/dist/agent.d.mts

@@ -0,0 +1,23 @@
+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 Claude Agent SDK
+ *
+ * Usage:
+ *   import { Agent } from 'claude-agent-sdk';
+ *   import { wrapAgent } from '@ato-sdk/js/agent';
+ *
+ *   const agent = wrapAgent(new Agent({ model: 'claude-sonnet-4-6' }));
+ *   // All agent runs are now auto-traced
+ *   const result = await agent.run('Fix the failing tests');
+ */
+type AgentInstance = {
+    run: (...args: any[]) => any;
+    [key: string]: any;
+};
+/**
+ * Wrap a Claude Agent SDK instance to auto-capture traces
+ */
+declare function wrapAgent<T extends AgentInstance>(agent: T): T;
+
+export { wrapAgent };

package/dist/agent.d.ts

@@ -0,0 +1,23 @@
+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 Claude Agent SDK
+ *
+ * Usage:
+ *   import { Agent } from 'claude-agent-sdk';
+ *   import { wrapAgent } from '@ato-sdk/js/agent';
+ *
+ *   const agent = wrapAgent(new Agent({ model: 'claude-sonnet-4-6' }));
+ *   // All agent runs are now auto-traced
+ *   const result = await agent.run('Fix the failing tests');
+ */
+type AgentInstance = {
+    run: (...args: any[]) => any;
+    [key: string]: any;
+};
+/**
+ * Wrap a Claude Agent SDK instance to auto-capture traces
+ */
+declare function wrapAgent<T extends AgentInstance>(agent: T): T;
+
+export { wrapAgent };

package/dist/agent.js

@@ -0,0 +1,319 @@
+"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/agent.ts
+var agent_exports = {};
+__export(agent_exports, {
+  MODEL_PRICING: () => MODEL_PRICING,
+  calculateCost: () => calculateCost,
+  getClient: () => getClient,
+  init: () => init,
+  wrapAgent: () => wrapAgent
+});
+module.exports = __toCommonJS(agent_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/agent.ts
+function wrapAgent(agent) {
+  const originalRun = agent.run.bind(agent);
+  agent.run = async function(...args) {
+    const prompt = typeof args[0] === "string" ? args[0] : args[0]?.prompt || "";
+    const start = Date.now();
+    let totalInputTokens = 0;
+    let totalOutputTokens = 0;
+    let totalCachedTokens = 0;
+    let model = agent.model || "claude-sonnet-4-6";
+    let toolCalls = 0;
+    let status = "success";
+    let error;
+    try {
+      const result = originalRun(...args);
+      if (result && Symbol.asyncIterator in result) {
+        const originalIterator = result[Symbol.asyncIterator].bind(result);
+        result[Symbol.asyncIterator] = async function* () {
+          for await (const message of originalIterator()) {
+            if (message.type === "usage" || message.usage) {
+              const usage = message.usage || message;
+              totalInputTokens += usage.input_tokens || 0;
+              totalOutputTokens += usage.output_tokens || 0;
+              totalCachedTokens += usage.cache_read_input_tokens || 0;
+            }
+            if (message.type === "tool_use" || message.type === "tool_call") {
+              toolCalls++;
+            }
+            if (message.model) {
+              model = message.model;
+            }
+            yield message;
+          }
+          captureAgentTrace({
+            start,
+            model,
+            prompt,
+            totalInputTokens,
+            totalOutputTokens,
+            totalCachedTokens,
+            toolCalls,
+            status,
+            error
+          });
+        };
+        return result;
+      }
+      const awaited = await result;
+      if (awaited?.usage) {
+        totalInputTokens = awaited.usage.input_tokens || 0;
+        totalOutputTokens = awaited.usage.output_tokens || 0;
+        totalCachedTokens = awaited.usage.cache_read_input_tokens || 0;
+      }
+      if (awaited?.model) model = awaited.model;
+      if (awaited?.tool_calls) toolCalls = awaited.tool_calls;
+      captureAgentTrace({
+        start,
+        model,
+        prompt,
+        totalInputTokens,
+        totalOutputTokens,
+        totalCachedTokens,
+        toolCalls,
+        status,
+        error
+      });
+      return awaited;
+    } catch (err) {
+      status = "error";
+      error = err.message || String(err);
+      captureAgentTrace({
+        start,
+        model,
+        prompt,
+        totalInputTokens,
+        totalOutputTokens,
+        totalCachedTokens,
+        toolCalls,
+        status,
+        error
+      });
+      throw err;
+    }
+  };
+  return agent;
+}
+function captureAgentTrace(params) {
+  const duration = Date.now() - params.start;
+  const trace = {
+    id: generateTraceId(),
+    provider: "anthropic-agent",
+    model: params.model,
+    inputTokens: params.totalInputTokens,
+    outputTokens: params.totalOutputTokens,
+    cachedTokens: params.totalCachedTokens,
+    totalTokens: params.totalInputTokens + params.totalOutputTokens,
+    costUsd: calculateCost(params.model, params.totalInputTokens, params.totalOutputTokens, params.totalCachedTokens),
+    durationMs: duration,
+    status: params.status,
+    error: params.error,
+    metadata: {
+      type: "agent-session",
+      prompt: params.prompt.slice(0, 200),
+      toolCalls: params.toolCalls
+    },
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  getClient().capture(trace);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MODEL_PRICING,
+  calculateCost,
+  getClient,
+  init,
+  wrapAgent
+});

package/dist/agent.mjs

@@ -0,0 +1,124 @@
+import {
+  MODEL_PRICING,
+  calculateCost,
+  generateTraceId,
+  getClient,
+  init
+} from "./chunk-Q2LJUUHK.mjs";
+
+// src/agent.ts
+function wrapAgent(agent) {
+  const originalRun = agent.run.bind(agent);
+  agent.run = async function(...args) {
+    const prompt = typeof args[0] === "string" ? args[0] : args[0]?.prompt || "";
+    const start = Date.now();
+    let totalInputTokens = 0;
+    let totalOutputTokens = 0;
+    let totalCachedTokens = 0;
+    let model = agent.model || "claude-sonnet-4-6";
+    let toolCalls = 0;
+    let status = "success";
+    let error;
+    try {
+      const result = originalRun(...args);
+      if (result && Symbol.asyncIterator in result) {
+        const originalIterator = result[Symbol.asyncIterator].bind(result);
+        result[Symbol.asyncIterator] = async function* () {
+          for await (const message of originalIterator()) {
+            if (message.type === "usage" || message.usage) {
+              const usage = message.usage || message;
+              totalInputTokens += usage.input_tokens || 0;
+              totalOutputTokens += usage.output_tokens || 0;
+              totalCachedTokens += usage.cache_read_input_tokens || 0;
+            }
+            if (message.type === "tool_use" || message.type === "tool_call") {
+              toolCalls++;
+            }
+            if (message.model) {
+              model = message.model;
+            }
+            yield message;
+          }
+          captureAgentTrace({
+            start,
+            model,
+            prompt,
+            totalInputTokens,
+            totalOutputTokens,
+            totalCachedTokens,
+            toolCalls,
+            status,
+            error
+          });
+        };
+        return result;
+      }
+      const awaited = await result;
+      if (awaited?.usage) {
+        totalInputTokens = awaited.usage.input_tokens || 0;
+        totalOutputTokens = awaited.usage.output_tokens || 0;
+        totalCachedTokens = awaited.usage.cache_read_input_tokens || 0;
+      }
+      if (awaited?.model) model = awaited.model;
+      if (awaited?.tool_calls) toolCalls = awaited.tool_calls;
+      captureAgentTrace({
+        start,
+        model,
+        prompt,
+        totalInputTokens,
+        totalOutputTokens,
+        totalCachedTokens,
+        toolCalls,
+        status,
+        error
+      });
+      return awaited;
+    } catch (err) {
+      status = "error";
+      error = err.message || String(err);
+      captureAgentTrace({
+        start,
+        model,
+        prompt,
+        totalInputTokens,
+        totalOutputTokens,
+        totalCachedTokens,
+        toolCalls,
+        status,
+        error
+      });
+      throw err;
+    }
+  };
+  return agent;
+}
+function captureAgentTrace(params) {
+  const duration = Date.now() - params.start;
+  const trace = {
+    id: generateTraceId(),
+    provider: "anthropic-agent",
+    model: params.model,
+    inputTokens: params.totalInputTokens,
+    outputTokens: params.totalOutputTokens,
+    cachedTokens: params.totalCachedTokens,
+    totalTokens: params.totalInputTokens + params.totalOutputTokens,
+    costUsd: calculateCost(params.model, params.totalInputTokens, params.totalOutputTokens, params.totalCachedTokens),
+    durationMs: duration,
+    status: params.status,
+    error: params.error,
+    metadata: {
+      type: "agent-session",
+      prompt: params.prompt.slice(0, 200),
+      toolCalls: params.toolCalls
+    },
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  getClient().capture(trace);
+}
+export {
+  MODEL_PRICING,
+  calculateCost,
+  getClient,
+  init,
+  wrapAgent
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ato-sdk/js",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Auto-capture LLM traces for ATO — works with Anthropic, OpenAI, and any LLM provider",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -20,14 +20,19 @@
       "import": "./dist/openai.mjs",
       "require": "./dist/openai.js",
       "types": "./dist/openai.d.ts"
+    },
+    "./agent": {
+      "import": "./dist/agent.mjs",
+      "require": "./dist/agent.js",
+      "types": "./dist/agent.d.ts"
     }
   },
   "files": [
     "dist"
   ],
   "scripts": {
-    "build": "tsup src/index.ts src/anthropic.ts src/openai.ts --format cjs,esm --dts --clean",
-    "dev": "tsup src/index.ts src/anthropic.ts src/openai.ts --format cjs,esm --dts --watch"
+    "build": "tsup src/index.ts src/anthropic.ts src/openai.ts src/agent.ts --format cjs,esm --dts --clean",
+    "dev": "tsup src/index.ts src/anthropic.ts src/openai.ts src/agent.ts --format cjs,esm --dts --watch"
   },
   "keywords": [
     "ato",
@@ -58,6 +63,7 @@
   },
   "peerDependenciesMeta": {
     "@anthropic-ai/sdk": { "optional": true },
-    "openai": { "optional": true }
+    "openai": { "optional": true },
+    "claude-agent-sdk": { "optional": true }
   }
 }