AI MonitoringCopy Anchor Link

npm install @codmir/sdk

import * as CodmirAI from '@codmir/sdk/ai';
import OpenAI from 'openai';
import Anthropic from '@anthropic-ai/sdk';

CodmirAI.init({
  dsn: process.env.CODMIR_DSN,
  apiKey: process.env.OVERSEER_KEY,
  trackTokenUsage: true,
  trackCosts: true,
  trackLatency: true,
});

// Wrap clients — all calls are now tracked automatically
const openai = CodmirAI.wrapOpenAI(new OpenAI());
const anthropic = CodmirAI.wrapAnthropic(new Anthropic());

// Use them as normal
const response = await openai.chat.completions.create({
  model: 'gpt-4o',
  messages: [{ role: 'user', content: 'Hello' }],
});

// Check accumulated stats
const summary = CodmirAI.getAIUsageSummary();
console.log(`Total cost: $${summary.totalCost.toFixed(4)}`);
console.log(`Avg latency: ${summary.avgLatencyMs}ms`);

import { wrapOpenAI } from '@codmir/sdk/ai';
import OpenAI from 'openai';

const openai = wrapOpenAI(new OpenAI());

// Every chat.completions.create call is now instrumented
const response = await openai.chat.completions.create({
  model: 'gpt-4o',
  messages: [{ role: 'user', content: 'Explain closures in JavaScript' }],
});
// Breadcrumb recorded: openai/gpt-4o — 142 tokens

import { wrapAnthropic } from '@codmir/sdk/ai';
import Anthropic from '@anthropic-ai/sdk';

const anthropic = wrapAnthropic(new Anthropic());

const response = await anthropic.messages.create({
  model: 'claude-sonnet-4-20250514',
  max_tokens: 1024,
  messages: [{ role: 'user', content: 'Hello' }],
});
// Breadcrumb recorded: anthropic/claude-sonnet-4-20250514 — 89 tokens

import { trackAICall } from '@codmir/sdk/ai';

const result = await trackAICall(
  'ollama',
  { model: 'llama-3', messageCount: 1 },
  async () => {
    return await myOllamaClient.chat({ prompt: 'Hello' });
  }
);

import { getAIUsageSummary } from '@codmir/sdk/ai';

const summary = getAIUsageSummary();

console.log(`Total calls: ${summary.totalCalls}`);
console.log(`Input tokens: ${summary.totalInputTokens}`);
console.log(`Output tokens: ${summary.totalOutputTokens}`);
console.log(`Total cost: $${summary.totalCost.toFixed(4)}`);
console.log(`Avg latency: ${summary.avgLatencyMs}ms`);

// Breakdown by provider
console.log(`OpenAI calls: ${summary.byProvider.openai?.calls ?? 0}`);
console.log(`Anthropic errors: ${summary.byProvider.anthropic?.errors ?? 0}`);

// Breakdown by model
console.log(`GPT-4o cost: $${summary.byModel['gpt-4o']?.cost.toFixed(4) ?? '0'}`);

import { resetAIUsageStats } from '@codmir/sdk/ai';

// Start a fresh tracking period
resetAIUsageStats();

import * as CodmirAI from '@codmir/sdk/ai';

const session = CodmirAI.startSession({
  agent: 'support-bot',
  metadata: { userId: 'u_123', ticket: 'T-456' },
  tags: { team: 'support', env: 'production' },
});

// All LLM calls are now correlated under this session
await openai.chat.completions.create({ /* ... */ });
await anthropic.messages.create({ /* ... */ });

// End the session
const completed = CodmirAI.endSession();
console.log(`Session made ${completed.usage.totalCalls} calls`);
console.log(`Total cost: $${completed.usage.totalCost.toFixed(4)}`);

CodmirAI.addSessionEvent('decision', {
  action: 'escalate_to_human',
  reason: 'confidence_below_threshold',
  confidence: 0.42,
});

CodmirAI.addSessionEvent('tool_call', {
  tool: 'search_tickets',
  query: 'login failed',
  results: 12,
});

CodmirAI.startSessionSpan('handle_user_message', { messageId: 'msg_789' });

await openai.chat.completions.create({ /* ... */ });
CodmirAI.addSessionEvent('decision', { action: 'respond_directly' });

CodmirAI.endSessionSpan();

const session = CodmirAI.endSession();
const success = await CodmirAI.flushSession(session);
if (success) {
  console.log('Session persisted for replay');
}

import { init } from '@codmir/sdk/ai';

init({
  // Core overseer settings
  dsn: process.env.CODMIR_DSN,
  apiKey: process.env.OVERSEER_KEY,
  environment: 'production',

  // Token and cost tracking (all default to true)
  trackTokenUsage: true,
  trackCosts: true,
  trackLatency: true,

  // Privacy-sensitive capture (both default to false)
  capturePrompts: false,
  captureResponses: false,

  // Redact patterns from captured content
  redactPatterns: [
    /sk-[a-zA-Z0-9]+/g,        // API keys
    /\b\d{4}-\d{4}-\d{4}\b/g,  // Card numbers
  ],

  // Custom cost table (per 1K tokens)
  costPerModel: {
    'my-fine-tuned-model': { input: 0.006, output: 0.012 },
  },
});

try {
  await openai.chat.completions.create({
    model: 'gpt-4o',
    messages: [{ role: 'user', content: 'Hello' }],
  });
} catch (error) {
  // Error already captured by Codmir with AI context
  // Your own error handling still runs
  console.error('OpenAI call failed:', error);
}

import {
  captureException,
  captureMessage,
  setUser,
  setTag,
  setTags,
  addBreadcrumb,
  flush,
  close,
} from '@codmir/sdk/ai';

import type {
  AIMonitorConfig,
  AICallParams,
  AICallResult,
  AIUsageSummary,
  ProviderStats,
  ModelStats,
  SessionConfig,
  SessionEvent,
  SessionSpan,
  AgentSession,
} from '@codmir/sdk/ai';