budget-agent 0.4.6 → 0.4.8

package/README.md

@@ -1,8 +1,8 @@
 # budget-agent
 
-Control LLM agent costs with real-time token, cost, and step tracking. Set budget limits, enforce spend caps, and prevent runaway agents from burning through your API credits.
+Stop runaway AI agents from burning through your API credits. Track cost, tokens, runtime, and steps. Enforce hard budget limits for OpenAI, Anthropic, LangGraph, LangChain, OpenRouter, CrewAI, Mastra, AutoGen, and any LLM workflow.
 
-**Works with OpenAI, Anthropic, OpenRouter, Ollama, Together AI, Fireworks, and any OpenAI-compatible endpoint.**
+budget-agent helps developers **track AI agent costs**, **enforce token limits**, **set spending caps**, **monitor LLM usage**, and **prevent runaway OpenAI, Anthropic, and OpenRouter agents** from exceeding budget. Works with every provider. Zero vendor lock-in.
 
 ## Install
 
@@ -13,113 +13,138 @@ npm install budget-agent
 ## Quick start
 
 ```ts
-import { AgentBudget } from 'budget-agent';
+import { AgentBudget, BudgetError } from 'budget-agent';
 
 const agent = new AgentBudget({
   apiKey: process.env.OPENROUTER_API_KEY,
-  limits: { maxCostUSD: 0.05, maxSteps: 10 },
+  limits: {
+    maxCostUSD:     0.10,
+    maxSteps:       15,
+    maxTotalTokens: 50_000,
+    maxWallTimeMs:  30_000,
+  },
 });
 
 const response = await agent.step({
-  model: 'anthropic/claude-opus-4.8-fast',
+  model: 'anthropic/claude-sonnet-4-5',
   messages: [{ role: 'user', content: 'Hello' }],
 });
 
 console.log(agent.getUsage());
-// { steps: 1, totalCostUSD: 0.000015, totalInputTokens: 12, ... }
 ```
 
-## Why use this
+---
 
-LLM API calls cost money. Agent loops multiply that cost across every step. Without guardrails, a single runaway agent can burn through your credits in seconds.
+## Prevent runaway AI agents
 
-This SDK sits between your agent and the LLM provider. It tracks every call, checks your budget before each one, and stops the agent when it hits a limit. No provider is bundled. No model is defaulted. You bring everything.
-
-## Budget limits
-
-Set limits on cost, tokens, steps, and wall time. Every limit is optional.
+Agent loops multiply LLM costs across every step. Without guardrails, a single loop can burn through your entire API budget in seconds. budget-agent blocks each call before and after it hits your provider -- so you never overspend.
 
 ```ts
 const agent = new AgentBudget({
   apiKey: key,
-  limits: {
-    maxCostUSD:      0.05,   // total USD before abort
-    maxSteps:        10,     // total LLM calls before abort
-    maxInputTokens:  50000,  // total input tokens
-    maxOutputTokens: 10000,  // total output tokens
-    maxTotalTokens:  60000,  // input + output combined
-    maxWallTimeMs:   60000,  // 60 seconds wall clock
-  },
+  limits: { maxCostUSD: 0.05, maxSteps: 10 },
 });
+
+try {
+  while (true) {
+    const res = await agent.step({ model, messages });
+    messages.push(res.choices[0].message);
+    messages.push({ role: 'user', content: 'Continue.' });
+  }
+} catch (err) {
+  if (err instanceof BudgetError) {
+    console.log('Agent stopped:', err.exceeded.reason);
+  }
+}
 ```
 
-### How enforcement works
+---
 
-Each `step()` runs two checks:
+## Track LLM costs in production
 
-1. **Pre-flight** -- before the API call. Estimates output cost and catches over-budget calls before spending money.
-2. **Post-step** -- after recording real token/cost data. If a limit is exceeded, the step is rolled back from the tracker so you can retry without a stale balance.
+Get real-time visibility into every API call. See cost per step, total spend, token breakdown, and wall time.
 
 ```ts
-try {
-  await agent.step({ model, messages });
-} catch (err) {
-  if (err instanceof BudgetError) {
-    console.log(err.exceeded.reason); // 'cost' | 'steps' | 'wallTime' | ...
-  }
+const usage = agent.getUsage();
+// {
+//   steps: 12,
+//   totalCostUSD: 0.0847,
+//   totalInputTokens: 24300,
+//   totalOutputTokens: 8200,
+//   elapsedMs: 45200,
+//   stepHistory: [...]
+// }
+
+agent.summary(); // formatted table in console
+```
+
+---
+
+## Set hard budget caps
+
+Every limit is optional. Set only what you need.
+
+```ts
+limits: {
+  maxCostUSD:      0.05,   // total USD across all steps
+  maxSteps:        10,     // total LLM calls
+  maxInputTokens:  50000,  // input tokens only
+  maxOutputTokens: 10000,  // output tokens only
+  maxTotalTokens:  60000,  // input + output combined
+  maxWallTimeMs:   60000,  // wall clock time in ms
 }
 ```
 
-### Custom callback instead of abort
+---
+
+## Runtime limits for AI agents
+
+Kill agents that run too long. Set wall time limits to prevent infinite loops from consuming compute and money.
 
 ```ts
 const agent = new AgentBudget({
   apiKey: key,
-  limits: { maxCostUSD: 0.01 },
-  onExceeded: (usage) => {
-    console.log(`Over budget: $${usage.totalCostUSD}`);
-    // Log, alert, switch models -- never throws
+  limits: {
+    maxWallTimeMs: 30_000,  // 30 second hard stop
+    maxCostUSD: 1.00,
   },
 });
 ```
 
-### Warning thresholds
+---
 
-Get notified before hitting limits:
+## Token usage tracking
 
-```ts
-const agent = new AgentBudget({
-  limits: { maxCostUSD: 0.10 },
-  warningThreshold: 0.5, // fire 'budget:warning' at 50% consumption
-});
+Track input tokens, output tokens, and total tokens across every step. Know exactly where your budget goes.
 
-agent.on('budget:warning', (e) => {
-  // { reason: 'cost', pctConsumed: 0.51, remaining: 0.049 }
+```ts
+agent.on('step:end', (e) => {
+  console.log(`Step ${e.stepIndex}: ${e.inputTokens} in / ${e.outputTokens} out / $${e.costUSD}`);
 });
 ```
 
-## Adaptive model routing
+---
+
+## Agent guardrails
 
-Downgrade to cheaper models as budget depletes:
+Pre-flight checks estimate output cost before the API call. Post-step checks record actual spend. If a limit is hit, the step rolls back and you can retry cleanly.
 
 ```ts
-const agent = new AgentBudget({
-  apiKey: key,
-  limits: { maxCostUSD: 5.00 },
-  adaptiveRouting: {
-    fallbackChain: [
-      'anthropic/claude-opus-4.8-fast', // best model
-      'openai/gpt-4o',                  // mid-tier
-      'openrouter/free',                // emergency fallback
-    ],
-    thresholds: [0.4, 0.75], // downgrade at 40% and 75% budget consumed
-  },
-});
+try {
+  await agent.step({ model, messages });
+} catch (err) {
+  if (err instanceof BudgetError) {
+    err.exceeded.reason;  // 'cost' | 'steps' | 'totalTokens' | 'wallTime'
+    err.exceeded.usage;   // full snapshot at cutoff
+  }
+}
 ```
 
-## Bring your own executor
+---
 
-Use any LLM provider with a custom executor:
+## OpenAI cost tracking
+
+Use budget-agent with the OpenAI SDK to track GPT-4, GPT-4o, and GPT-3.5 costs in real time.
 
 ```ts
 import { AgentBudget } from 'budget-agent';
@@ -129,7 +154,7 @@ const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
 
 const agent = new AgentBudget({
   apiKey: process.env.OPENAI_API_KEY,
-  limits: { maxCostUSD: 0.10 },
+  limits: { maxCostUSD: 0.50 },
   executor: async (request) => {
     const completion = await openai.chat.completions.create({
       model: request.model,
@@ -151,105 +176,402 @@ const agent = new AgentBudget({
 });
 ```
 
-Works with OpenAI, Anthropic, Ollama, Together AI, Fireworks, LocalAI, or any OpenAI-compatible API.
+---
 
-## Features
+## Anthropic budget limits
 
-- **Budget enforcement** -- cost, tokens, steps, wall time limits checked before and after every LLM call
-- **Adaptive routing** -- automatic model downgrade as budget depletes
-- **Circuit breaker** -- detect repetition or stagnation and halt the agent
-- **Auto-compress** -- truncate message history with LLM summary when tokens exceed threshold
-- **Checkpoints** -- save and resume agent state across restarts
-- **Streaming** -- set `stream: true` and listen for `step:token` events
-- **Events** -- subscribe to `step:start`, `step:end`, `step:token`, `budget:exceeded`, and more
-- **Pricing cache** -- model pricing fetched from OpenRouter with configurable TTL
-- **Rate-limit retry** -- automatic 429 retry with exponential backoff
-- **OpenTelemetry** -- optional tracing spans via `telemetry: { enabled: true }`
+Set spending caps on Claude Opus, Sonnet, and Haiku. Track token usage and enforce cost limits for Anthropic models.
 
-## API
+```ts
+const agent = new AgentBudget({
+  apiKey: process.env.ANTHROPIC_API_KEY,
+  limits: { maxCostUSD: 0.25, maxSteps: 20 },
+  executor: async (request) => {
+    const response = await fetch('https://api.anthropic.com/v1/messages', {
+      method: 'POST',
+      headers: {
+        'x-api-key': process.env.ANTHROPIC_API_KEY!,
+        'anthropic-version': '2023-06-01',
+        'content-type': 'application/json',
+      },
+      body: JSON.stringify({
+        model: request.model,
+        messages: request.messages,
+        max_tokens: 1024,
+      }),
+    });
+    const data = await response.json();
+    return {
+      model: data.model,
+      usage: {
+        prompt_tokens: data.usage?.input_tokens ?? 0,
+        completion_tokens: data.usage?.output_tokens ?? 0,
+        total_tokens: (data.usage?.input_tokens ?? 0) + (data.usage?.output_tokens ?? 0),
+      },
+      choices: [{
+        message: { role: 'assistant', content: data.content?.[0]?.text ?? '' },
+        finish_reason: 'stop',
+      }],
+    };
+  },
+});
+```
 
-### `new AgentBudget(options)`
+---
 
-| Option | Type | Default | Description |
-|--------|------|---------|-------------|
-| `apiKey` | `string` | -- | Your provider API key |
-| `limits` | `object` | -- | Budget limits (cost, tokens, steps, wall time) |
-| `executor` | `function` | -- | Custom API executor (replaces built-in fetch) |
-| `baseUrl` | `string` | `https://openrouter.ai/api/v1` | API base URL |
-| `defaultHeaders` | `object` | -- | Extra HTTP headers |
-| `autoCompress` | `object` | -- | Auto-compress messages at token threshold |
-| `circuitBreaker` | `object` | -- | Detect repetition/stagnation loops |
-| `adaptiveRouting` | `object` | -- | Downgrade model tiers as budget depletes |
-| `checkpoint` | `object` | -- | Persist and resume agent state |
-| `onExceeded` | `'abort' \| function` | `'abort'` | Strategy when budget exceeded |
-| `onEvent` | `function` | -- | Global event listener |
-| `warningThreshold` | `number` | `0.75` | Fraction of limit that triggers warning |
-| `pricingCacheTTLMs` | `number` | `300000` | Pricing cache TTL in ms |
-| `telemetry` | `object` | -- | Enable OpenTelemetry spans |
+## LangGraph budget control
 
-### `agent.step(request)`
+Add budget limits to LangGraph agent graphs. Prevent infinite loops and control cost per execution.
+
+```ts
+import { AgentBudget, BudgetError } from 'budget-agent';
+
+const agent = new AgentBudget({
+  apiKey: process.env.OPENROUTER_API_KEY,
+  limits: { maxCostUSD: 0.20, maxSteps: 50 },
+});
+
+// Use inside a LangGraph node
+async function agentNode(state) {
+  const response = await agent.step({
+    model: 'anthropic/claude-sonnet-4-5',
+    messages: state.messages,
+  });
+  return { messages: [...state.messages, response.choices[0].message] };
+}
+```
+
+---
+
+## LangChain cost monitoring
 
-Make one LLM call. Checks limits before and after. Throws `BudgetError` if exceeded.
+Track costs for LangChain chains and agents. Set token limits and spending caps.
 
 ```ts
+import { AgentBudget } from 'budget-agent';
+
+const agent = new AgentBudget({
+  apiKey: process.env.OPENROUTER_API_KEY,
+  limits: { maxCostUSD: 0.15, maxTotalTokens: 100_000 },
+});
+
+// Wrap any LangChain call
 const response = await agent.step({
-  model: 'anthropic/claude-opus-4.8-fast',
-  messages: [{ role: 'user', content: 'Hi' }],
-  stream: true, // optional -- emit step:token events
+  model: 'openai/gpt-4o',
+  messages: [{ role: 'user', content: prompt }],
 });
 ```
 
-### `agent.getUsage()`
+---
+
+## OpenRouter spend caps
 
-Returns current usage snapshot:
+budget-agent fetches live pricing from OpenRouter. No hardcoded price tables. If OpenRouter adds a model, it works automatically.
 
 ```ts
-{
-  steps: number;
-  totalInputTokens: number;
-  totalOutputTokens: number;
-  totalCostUSD: number;
-  elapsedMs: number;
-  stepHistory: StepUsage[];
-}
+const agent = new AgentBudget({
+  apiKey: process.env.OPENROUTER_API_KEY,
+  limits: { maxCostUSD: 0.10 },
+});
+
+// Pricing is fetched and cached automatically
+const response = await agent.step({
+  model: 'anthropic/claude-sonnet-4-5',
+  messages: [{ role: 'user', content: 'Hello' }],
+});
 ```
 
-### `agent.summary()`
+---
 
-Prints a formatted table to console and returns the usage snapshot.
+## Ollama agent limits
 
-### `agent.reset()`
+Set budget limits for local Ollama models. Track token usage even for self-hosted inference.
+
+```ts
+const agent = new AgentBudget({
+  apiKey: 'ollama',
+  limits: { maxSteps: 100, maxWallTimeMs: 60_000 },
+  baseUrl: 'http://localhost:11434/v1',
+  executor: async (request) => {
+    const res = await fetch('http://localhost:11434/api/chat', {
+      method: 'POST',
+      body: JSON.stringify({ model: request.model, messages: request.messages }),
+    });
+    const data = await res.json();
+    return {
+      model: data.model,
+      usage: data.usage ?? { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 },
+      choices: data.messages?.map((m) => ({
+        message: { role: m.role, content: m.content },
+        finish_reason: 'stop',
+      })) ?? [],
+    };
+  },
+});
+```
 
-Reset all usage counters.
+---
 
-### `agent.compressMessages(messages, keepLastN?)`
+## CrewAI budget enforcement
 
-Manually compress a message array via LLM summary.
+Add cost limits to CrewAI agent crews. Prevent multi-agent systems from running up bills.
 
-### `agent.loadCheckpoint()` / `agent.clearCheckpoint()`
+```ts
+import { AgentBudget } from 'budget-agent';
 
-Load or clear persisted checkpoint state.
+const agent = new AgentBudget({
+  apiKey: process.env.OPENROUTER_API_KEY,
+  limits: { maxCostUSD: 1.00, maxSteps: 100 },
+});
 
-### `AgentBudget.resume(options, checkpointPath?)`
+// Use in CrewAI task execution
+const response = await agent.step({
+  model: 'anthropic/claude-sonnet-4-5',
+  messages: [{ role: 'user', content: taskDescription }],
+});
+```
+
+---
 
-Static factory. Creates a new agent pre-loaded with checkpoint state.
+## Mastra agent limits
 
-## Events
+Set budget limits for Mastra agents. Track cost and tokens across agent workflows.
+
+```ts
+import { AgentBudget } from 'budget-agent';
+
+const agent = new AgentBudget({
+  apiKey: process.env.OPENROUTER_API_KEY,
+  limits: { maxCostUSD: 0.50, maxSteps: 30 },
+});
+```
+
+---
+
+## AutoGen cost control
+
+Add budget limits to AutoGen multi-agent conversations. Prevent agent loops from exceeding budget.
+
+```ts
+import { AgentBudget } from 'budget-agent';
+
+const agent = new AgentBudget({
+  apiKey: process.env.OPENROUTER_API_KEY,
+  limits: { maxCostUSD: 0.25, maxSteps: 20 },
+});
+```
+
+---
+
+## LLM observability
+
+Subscribe to lifecycle events for full visibility into agent behavior.
 
 ```ts
 agent.on('step:start', (e) => console.log('Step', e.stepIndex, 'started'));
 agent.on('step:token', (e) => process.stdout.write(e.token));
-agent.on('step:end', (e) => console.log('Step cost:', e.costUSD));
+agent.on('step:end', (e) => console.log(`Step cost: $${e.costUSD}`));
 agent.on('budget:exceeded', (e) => console.log('Limit hit:', e.exceeded.reason));
-agent.on('model:downgraded', (e) => console.log('Downgraded to', e.to));
+agent.on('budget:warning', (e) => console.log(`Warning: ${e.pctConsumed * 100}% consumed`));
+agent.on('model:downgraded', (e) => console.log(`Downgraded: ${e.from} → ${e.to}`));
 ```
 
-## Testing
+---
 
-```bash
-npm test
+## Adaptive model routing
+
+Downgrade to cheaper models as budget depletes. Automatic fallback chains.
+
+```ts
+const agent = new AgentBudget({
+  apiKey: key,
+  limits: { maxCostUSD: 5.00 },
+  adaptiveRouting: {
+    fallbackChain: [
+      'anthropic/claude-opus-4.8-fast',
+      'openai/gpt-4o',
+      'openrouter/free',
+    ],
+    thresholds: [0.4, 0.75],
+  },
+});
+```
+
+---
+
+## Circuit breaker
+
+Detect repetition or stagnation and halt the agent before it burns through credits.
+
+```ts
+const agent = new AgentBudget({
+  apiKey: key,
+  limits: { maxCostUSD: 1.00 },
+  circuitBreaker: {
+    repetitionWindow: 3,
+    repetitionThreshold: 0.85,
+    stagnationWindow: 4,
+    stagnationMinLength: 50,
+  },
+});
+```
+
+---
+
+## Auto-compress messages
+
+Truncate message history with an LLM summary when token count exceeds a threshold.
+
+```ts
+const agent = new AgentBudget({
+  apiKey: key,
+  limits: { maxTotalTokens: 100_000 },
+  autoCompress: {
+    thresholdTokens: 80_000,
+    keepLastN: 4,
+  },
+});
 ```
 
+---
+
+## Checkpoints
+
+Save and resume agent state across restarts.
+
+```ts
+const agent = new AgentBudget({
+  apiKey: key,
+  limits: { maxCostUSD: 0.50 },
+  checkpoint: { enabled: true, path: './agent-state.json' },
+});
+
+// Resume later
+const resumed = await AgentBudget.resume(options);
+```
+
+---
+
+## Warning thresholds
+
+Get notified before hitting limits.
+
+```ts
+const agent = new AgentBudget({
+  limits: { maxCostUSD: 0.10 },
+  warningThreshold: 0.5,
+});
+
+agent.on('budget:warning', (e) => {
+  console.log(`${e.pctConsumed * 100}% of ${e.reason} budget consumed`);
+});
+```
+
+---
+
+## budget-agent vs LangSmith
+
+LangSmith is an observability platform. budget-agent is a runtime enforcement layer. LangSmith shows you what happened. budget-agent stops it from happening.
+
+| | budget-agent | LangSmith |
+|---|---|---|
+| Runtime enforcement | Yes | No |
+| Pre-flight cost estimation | Yes | No |
+| Budget limits | Hard stops | Soft alerts |
+| Pricing | Free, self-hosted | Paid SaaS |
+| Provider lock-in | None | LangChain ecosystem |
+
+---
+
+## budget-agent vs Helicone
+
+Helicone is a proxy for LLM cost tracking. budget-agent is an SDK that enforces limits at runtime. Helicone tracks after the fact. budget-agent blocks before spend happens.
+
+| | budget-agent | Helicone |
+|---|---|---|
+| Runtime enforcement | Yes | No |
+| Pre-flight checks | Yes | No |
+| Self-hosted | Yes | Cloud only |
+| Free tier | Yes | Limited |
+
+---
+
+## budget-agent vs Langfuse
+
+Langfuse is an LLM observability tool. budget-agent is a budget enforcement SDK. Langfuse gives you dashboards. budget-agent gives you hard limits.
+
+| | budget-agent | Langfuse |
+|---|---|---|
+| Runtime enforcement | Yes | No |
+| Pre-flight cost estimation | Yes | No |
+| Budget limits | Hard stops | Observability only |
+| Self-hosted | Yes | Yes |
+| Free | Yes | Yes (self-hosted) |
+
+---
+
+## budget-agent vs OpenAI Usage Dashboard
+
+OpenAI's dashboard shows usage after the fact. budget-agent prevents overspend in real time.
+
+| | budget-agent | OpenAI Dashboard |
+|---|---|---|
+| Real-time enforcement | Yes | No |
+| Pre-flight checks | Yes | No |
+| Multi-provider | Yes | OpenAI only |
+| Agent loop protection | Yes | No |
+
+---
+
+## API
+
+### `new AgentBudget(options)`
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `apiKey` | `string` | required | Your provider API key |
+| `limits` | `object` | required | Budget limits (cost, tokens, steps, wall time) |
+| `executor` | `function` | -- | Custom API executor |
+| `baseUrl` | `string` | `https://openrouter.ai/api/v1` | API base URL |
+| `defaultHeaders` | `object` | -- | Extra HTTP headers |
+| `autoCompress` | `object` | -- | Auto-compress messages at token threshold |
+| `circuitBreaker` | `object` | -- | Detect repetition/stagnation |
+| `adaptiveRouting` | `object` | -- | Downgrade models as budget depletes |
+| `checkpoint` | `object` | -- | Persist and resume agent state |
+| `onExceeded` | `'abort' \| function` | `'abort'` | Strategy when limit hit |
+| `onEvent` | `function` | -- | Global event listener |
+| `warningThreshold` | `number` | `0.75` | Warning at this fraction of any limit |
+| `pricingCacheTTLMs` | `number` | `300000` | Pricing cache TTL |
+| `telemetry` | `object` | -- | Enable OpenTelemetry spans |
+
+### `agent.step(request)`
+
+One LLM call. Checks limits before and after. Throws `BudgetError` on exceed.
+
+### `agent.getUsage()`
+
+Returns: `steps`, `totalInputTokens`, `totalOutputTokens`, `totalCostUSD`, `elapsedMs`, `stepHistory`.
+
+### `agent.reset()`
+
+Reset all counters.
+
+### `agent.refreshPricing()`
+
+Force re-fetch model prices.
+
+### `agent.summary()`
+
+Formatted usage table in console.
+
+### `agent.loadCheckpoint()` / `agent.clearCheckpoint()`
+
+Load or clear persisted state.
+
+### `AgentBudget.resume(options, checkpointPath?)`
+
+Create a new agent pre-loaded with checkpoint state.
+
 ## License
 
 MIT

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "budget-agent",
-  "version": "0.4.6",
-  "description": "Control LLM agent costs with real-time token, cost, and step tracking. Set budget limits, enforce spend caps, and prevent runaway agents. Works with OpenAI, Anthropic, OpenRouter, Ollama, and any provider.",
+  "version": "0.4.8",
+  "description": "Track AI agent costs, tokens, runtime and spending. Prevent runaway OpenAI, Anthropic, LangGraph and OpenRouter agents from exceeding budget.",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -29,31 +29,41 @@
     "test:legacy": "tsx test-integration.ts"
   },
   "keywords": [
-    "llm",
+    "ai",
     "agent",
-    "budget",
-    "cost-control",
-    "token-limit",
-    "openrouter",
+    "llm",
     "openai",
     "anthropic",
-    "llm-cost",
+    "langgraph",
+    "langchain",
+    "openrouter",
+    "ollama",
+    "crewai",
+    "mastra",
+    "autogen",
+    "cost-tracking",
+    "budget",
+    "token-tracking",
     "agent-budget",
+    "ai-cost",
+    "ai-observability",
+    "agent-monitoring",
+    "guardrails",
+    "runtime-limits",
+    "token-limits",
     "spending-limit",
-    "rate-limit",
+    "cost-control",
+    "llm-cost",
+    "agent-guardrails",
+    "runaway-agent",
+    "budget-enforcement",
     "circuit-breaker",
     "checkpoint",
-    "token-tracker",
-    "cost-tracker",
-    "llm-agent",
-    "ai-agent",
-    "prompt-cost",
-    "usage-tracking",
-    "budget-enforcement",
-    "ollama",
     "gpt-4",
     "claude",
-    "llm-proxy"
+    "langsmith",
+    "langfuse",
+    "helicone"
   ],
   "license": "MIT",
   "repository": {