@aispendguard/sdk 0.1.0

package/dist/langchain.js

@@ -0,0 +1,197 @@
+"use strict";
+/**
+ * LangChain.js callback handler for AISpendGuard.
+ *
+ * Tracks LLM token usage from LangChain invocations via the SDK singleton.
+ * Never reads prompt content or model outputs — only metadata and token counts.
+ *
+ * Usage:
+ *   import { init, AISpendGuardCallbackHandler } from "@aispendguard/sdk";
+ *
+ *   init({ apiKey: "asg_..." });
+ *   const handler = new AISpendGuardCallbackHandler({
+ *     defaultTags: { feature: "chatbot", route: "/api/chat" },
+ *   });
+ *
+ *   const llm = new ChatOpenAI({ callbacks: [handler] });
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AISpendGuardCallbackHandler = void 0;
+const index_1 = require("./index");
+/**
+ * Minimal abstract base we implement. At runtime LangChain will duck-type
+ * check the handler; it doesn't require `extends BaseCallbackHandler` from
+ * the exact same package version — it only needs the method signatures and
+ * the `name` property.
+ */
+class BaseCallbackHandlerCompat {
+    constructor() {
+        this.lc_serializable = false;
+        this.ignoreLLM = false;
+        this.ignoreChain = true;
+        this.ignoreAgent = true;
+        this.ignoreRetriever = true;
+        this.ignoreCustomEvent = true;
+    }
+}
+// ---------------------------------------------------------------------------
+// Provider detection
+// ---------------------------------------------------------------------------
+const PROVIDER_PATTERNS = [
+    [/openai/i, "openai"],
+    [/anthropic|claude/i, "anthropic"],
+    [/google|gemini|vertex/i, "google"],
+    [/cohere/i, "cohere"],
+    [/mistral/i, "mistral"],
+    [/bedrock/i, "aws_bedrock"],
+    [/azure/i, "azure_openai"],
+    [/ollama/i, "ollama"],
+    [/groq/i, "groq"],
+    [/together/i, "together"],
+    [/fireworks/i, "fireworks"],
+];
+function detectProvider(serialized) {
+    if (!serialized)
+        return "unknown";
+    // Check serialized id array (e.g. ["langchain", "chat_models", "openai", "ChatOpenAI"])
+    const idStr = (serialized.id ?? []).join("/").toLowerCase();
+    for (const [pattern, provider] of PROVIDER_PATTERNS) {
+        if (pattern.test(idStr))
+            return provider;
+    }
+    // Check name
+    const name = serialized.name ?? "";
+    for (const [pattern, provider] of PROVIDER_PATTERNS) {
+        if (pattern.test(name))
+            return provider;
+    }
+    return "unknown";
+}
+function extractModel(serialized, llmOutput) {
+    // Try llmOutput first (most reliable after completion)
+    if (llmOutput) {
+        const modelName = llmOutput.model ??
+            llmOutput.model_name ??
+            llmOutput.modelName ??
+            llmOutput.model_id;
+        if (typeof modelName === "string" && modelName.length > 0) {
+            return modelName;
+        }
+    }
+    // Try serialized kwargs
+    if (serialized) {
+        const kwargs = serialized.kwargs;
+        if (kwargs) {
+            const modelName = kwargs.model ??
+                kwargs.model_name ??
+                kwargs.modelName ??
+                kwargs.model_id;
+            if (typeof modelName === "string" && modelName.length > 0) {
+                return modelName;
+            }
+        }
+    }
+    return "unknown";
+}
+class AISpendGuardCallbackHandler extends BaseCallbackHandlerCompat {
+    constructor(config) {
+        super();
+        this.name = "AISpendGuardCallbackHandler";
+        this.runs = new Map();
+        this.defaultTags = config?.defaultTags ?? {};
+    }
+    // -- LLM lifecycle callbacks --
+    handleLLMStart(serialized, _prompts, runId, _parentRunId, _extraParams, _tags, _metadata, _name) {
+        // Record start time. NEVER read prompts.
+        const id = runId ?? crypto.randomUUID();
+        this.runs.set(id, { startedAt: Date.now(), serialized });
+    }
+    handleChatModelStart(serialized, _messages, runId, _parentRunId, _extraParams, _tags, _metadata, _name) {
+        // Record start time. NEVER read messages.
+        const id = runId ?? crypto.randomUUID();
+        this.runs.set(id, { startedAt: Date.now(), serialized });
+    }
+    handleLLMEnd(output, runId, _parentRunId, _tags) {
+        const id = runId ?? "";
+        const runInfo = this.runs.get(id);
+        const startedAt = runInfo?.startedAt ?? Date.now();
+        const serialized = runInfo?.serialized;
+        // Clean up
+        if (id)
+            this.runs.delete(id);
+        const latencyMs = Math.max(0, Date.now() - startedAt);
+        // Extract token usage from llmOutput
+        const llmOutput = output.llmOutput ?? {};
+        const tokenUsage = (llmOutput.tokenUsage ??
+            llmOutput.token_usage ??
+            llmOutput.usage ??
+            {});
+        const inputTokens = toNumber(tokenUsage.promptTokens ??
+            tokenUsage.prompt_tokens ??
+            tokenUsage.input_tokens ??
+            tokenUsage.totalInputTokens);
+        const outputTokens = toNumber(tokenUsage.completionTokens ??
+            tokenUsage.completion_tokens ??
+            tokenUsage.output_tokens ??
+            tokenUsage.totalOutputTokens);
+        // Skip if we got no token data at all
+        if (inputTokens === 0 && outputTokens === 0)
+            return;
+        const provider = detectProvider(serialized);
+        const model = extractModel(serialized, llmOutput);
+        // Build tags
+        const tags = {
+            ...this.defaultTags,
+            source: "langchain",
+            task_type: this.defaultTags.task_type ?? "chat",
+            feature: this.defaultTags.feature ?? "default",
+            route: this.defaultTags.route ?? "default",
+        };
+        const event = {
+            provider,
+            model,
+            inputTokens,
+            outputTokens,
+            latencyMs,
+            timestamp: new Date(),
+            tags,
+            // Use run_id as event_id for deduplication
+            ...(id ? { eventId: `langchain:${id}` } : {}),
+        };
+        // Fire and forget — never block the LLM chain
+        const client = getClientSafe();
+        if (client) {
+            client.trackUsage(event).catch((err) => {
+                console.warn(`[aispendguard-langchain] Failed to track usage: ${err instanceof Error ? err.message : String(err)}`);
+            });
+        }
+    }
+    handleLLMError(_err, runId) {
+        // Clean up run tracking; never throw
+        const id = runId ?? "";
+        if (id)
+            this.runs.delete(id);
+    }
+}
+exports.AISpendGuardCallbackHandler = AISpendGuardCallbackHandler;
+// ---------------------------------------------------------------------------
+// Internal helpers
+// ---------------------------------------------------------------------------
+function toNumber(value) {
+    if (typeof value === "number" && !Number.isNaN(value))
+        return value;
+    if (typeof value === "string") {
+        const n = Number(value);
+        return Number.isNaN(n) ? 0 : n;
+    }
+    return 0;
+}
+function getClientSafe() {
+    try {
+        return (0, index_1.getClient)();
+    }
+    catch {
+        console.warn("[aispendguard-langchain] SDK not initialized. Call init() before using the LangChain handler.");
+        return null;
+    }
+}

package/dist/openai.d.ts

@@ -0,0 +1,46 @@
+import type { UsageEventInput, UsageTags } from "./types";
+/**
+ * Covers both OpenAI Chat Completions and Responses API response.usage shapes.
+ *
+ * Chat Completions: prompt_tokens / completion_tokens
+ *   - prompt_tokens_details.cached_tokens        → cache read (0.5× base input price)
+ *   - completion_tokens_details.reasoning_tokens → o1/o3 thinking (billed as output)
+ *
+ * Responses API: input_tokens / output_tokens
+ *   - input_tokens_details.cached_tokens         → cache read (0.5× base input price)
+ *   - output_tokens_details.reasoning_tokens     → o1/o3 thinking (billed as output)
+ */
+type OpenAIUsageLike = {
+    input_tokens?: number;
+    output_tokens?: number;
+    input_tokens_details?: {
+        cached_tokens?: number;
+    };
+    output_tokens_details?: {
+        reasoning_tokens?: number;
+    };
+    prompt_tokens?: number;
+    completion_tokens?: number;
+    prompt_tokens_details?: {
+        cached_tokens?: number;
+    };
+    completion_tokens_details?: {
+        reasoning_tokens?: number;
+    };
+};
+export type OpenAIEventParams = {
+    model: string;
+    /**
+     * The resolved model name as returned in response.model (e.g. "gpt-4o-mini-2024-07-18").
+     * Pass response.model here for accurate model version tracking.
+     */
+    resolvedModel?: string;
+    usage: OpenAIUsageLike | null | undefined;
+    latencyMs: number;
+    timestamp?: string | Date;
+    costUsd?: number;
+    tags: UsageTags;
+    eventId?: string;
+};
+export declare function createOpenAIUsageEvent(params: OpenAIEventParams): UsageEventInput;
+export {};

package/dist/openai.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createOpenAIUsageEvent = createOpenAIUsageEvent;
+function getInputTokens(usage) {
+    if (!usage)
+        return 0;
+    if (typeof usage.input_tokens === "number")
+        return usage.input_tokens;
+    if (typeof usage.prompt_tokens === "number")
+        return usage.prompt_tokens;
+    return 0;
+}
+function getOutputTokens(usage) {
+    if (!usage)
+        return 0;
+    if (typeof usage.output_tokens === "number")
+        return usage.output_tokens;
+    if (typeof usage.completion_tokens === "number")
+        return usage.completion_tokens;
+    return 0;
+}
+/** Cache read tokens — billed at 0.25×–0.5× base input price (varies by model family). Already counted in inputTokens. */
+function getCachedTokens(usage) {
+    if (!usage)
+        return undefined;
+    const v = usage.input_tokens_details?.cached_tokens ??
+        usage.prompt_tokens_details?.cached_tokens;
+    return typeof v === "number" ? v : undefined;
+}
+/**
+ * Reasoning tokens for o1/o3 models — billed as output tokens.
+ * Already counted in outputTokens; stored separately for cost spike detection.
+ */
+function getReasoningTokens(usage) {
+    if (!usage)
+        return undefined;
+    const v = usage.output_tokens_details?.reasoning_tokens ??
+        usage.completion_tokens_details?.reasoning_tokens;
+    return typeof v === "number" ? v : undefined;
+}
+function createOpenAIUsageEvent(params) {
+    const cached = getCachedTokens(params.usage);
+    const thinking = getReasoningTokens(params.usage);
+    return {
+        eventId: params.eventId,
+        provider: "openai",
+        model: params.model,
+        resolvedModel: params.resolvedModel,
+        inputTokens: getInputTokens(params.usage),
+        outputTokens: getOutputTokens(params.usage),
+        ...(typeof cached === "number" ? { inputTokensCached: cached } : {}),
+        ...(typeof thinking === "number" ? { thinkingTokens: thinking } : {}),
+        latencyMs: params.latencyMs,
+        costUsd: params.costUsd,
+        timestamp: params.timestamp ?? new Date(),
+        tags: params.tags
+    };
+}

package/dist/types.d.ts

@@ -0,0 +1,95 @@
+export type AllowedTagKey = "task_type" | "feature" | "route" | "customer_plan" | "customer_id" | "provider" | "model" | "environment" | "agent_name";
+export type TagValue = string | string[];
+export type UsageTags = Partial<Record<AllowedTagKey, string>> & Record<string, TagValue>;
+export type UsageEventInput = {
+    eventId?: string;
+    provider: string;
+    model: string;
+    /** Resolved model name from provider response (e.g. "gpt-4o-mini-2024-07-18" vs "gpt-4o-mini"). */
+    resolvedModel?: string;
+    inputTokens: number;
+    outputTokens: number;
+    /**
+     * Cache read tokens — billed at a reduced rate.
+     * OpenAI: 0.5× base input price. Anthropic: 0.1× base input price.
+     * Already included in inputTokens; stored separately for accurate cost calculation.
+     */
+    inputTokensCached?: number;
+    /**
+     * Cache write tokens — billed at a premium rate (Anthropic only: 1.25× base input price).
+     * Already included in inputTokens; stored separately for accurate cost calculation.
+     */
+    inputTokensCacheWrite?: number;
+    /**
+     * Reasoning / thinking tokens — billed as output tokens.
+     * OpenAI o1/o3: from completion_tokens_details.reasoning_tokens.
+     * Google Gemini 2.5: from usageMetadata.thoughtsTokenCount.
+     * Anthropic extended thinking: included in output_tokens (not separately reported in usage).
+     * Already included in outputTokens; stored separately for cost spike detection.
+     */
+    thinkingTokens?: number;
+    /**
+     * Anthropic cache write TTL: "5m" (default, 1.25× input price) or "1h" (extended, 2.0× input price).
+     * Only relevant when inputTokensCacheWrite > 0.
+     */
+    cacheTtl?: "5m" | "1h";
+    /** Number of web search tool calls (billed as flat fee per call). */
+    webSearchCount?: number;
+    /** Number of web fetch tool calls (billed as flat fee per call). */
+    webFetchCount?: number;
+    /** Whether this request used the Batch API (50% discount on token costs). */
+    isBatchApi?: boolean;
+    /** Whether fast mode was used (Opus 6× multiplier on token costs). */
+    isFastMode?: boolean;
+    latencyMs: number;
+    costUsd?: number;
+    timestamp: string | Date;
+    tags: UsageTags;
+};
+export type UsageEventBatchInput = UsageEventInput | UsageEventInput[];
+export type IngestEventPayload = {
+    event_id?: string;
+    provider: string;
+    model: string;
+    resolved_model?: string;
+    input_tokens: number;
+    output_tokens: number;
+    input_tokens_cached?: number;
+    input_tokens_cache_write?: number;
+    thinking_tokens?: number;
+    cache_ttl?: "5m" | "1h";
+    web_search_count?: number;
+    web_fetch_count?: number;
+    is_batch_api?: boolean;
+    is_fast_mode?: boolean;
+    latency_ms: number;
+    cost_usd?: number;
+    timestamp: string;
+    tags: Record<string, TagValue>;
+};
+export type IngestRequestPayload = {
+    events: IngestEventPayload[];
+};
+export type IngestResponse = {
+    accepted: number;
+    duplicates: number;
+    rejected: number;
+    errors?: string[];
+};
+export type ClientConfig = {
+    apiKey: string;
+    endpoint?: string;
+    /** Default tags merged into every auto-wrapped event. */
+    defaultTags?: UsageTags;
+    timeoutMs?: number;
+    maxRetries?: number;
+    strict?: boolean;
+    logger?: Pick<Console, "warn" | "error" | "info">;
+};
+export type TrackResult = {
+    ok: true;
+    response: IngestResponse;
+} | {
+    ok: false;
+    error: string;
+};

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/validate.d.ts

@@ -0,0 +1,2 @@
+import type { IngestEventPayload, UsageEventInput } from "./types";
+export declare function normalizeEvent(event: UsageEventInput): IngestEventPayload;

package/dist/validate.js

@@ -0,0 +1,188 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeEvent = normalizeEvent;
+const REQUIRED_TAGS = ["task_type", "feature", "route"];
+const ALLOWED_TAGS = new Set([
+    ...REQUIRED_TAGS,
+    "customer_plan",
+    "customer_id",
+    "provider",
+    "model",
+    "environment",
+    "agent_name"
+]);
+const CUSTOM_TAG_KEY_PATTERN = /^[a-z][a-z0-9_]{1,63}$/;
+const MAX_TAGS_PER_EVENT = 24;
+const MAX_TAG_VALUE_LENGTH = 120;
+const MAX_TAG_ARRAY_ITEMS = 16;
+const MAX_STRING_FIELD_LENGTH = 256;
+const FORBIDDEN_KEYS = [
+    "prompt",
+    "prompts",
+    "input",
+    "inputs",
+    "completion",
+    "completions",
+    "output",
+    "outputs",
+    "content",
+    "message",
+    "messages",
+    "attachment",
+    "attachments"
+];
+function isObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function containsForbiddenKeys(obj) {
+    const lower = Object.keys(obj).map((k) => k.toLowerCase());
+    const found = FORBIDDEN_KEYS.find((k) => lower.includes(k));
+    return found ?? null;
+}
+function assertNonEmptyString(value, field, maxLength = MAX_STRING_FIELD_LENGTH) {
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw new Error(`${field} must be a non-empty string`);
+    }
+    if (value.trim().length > maxLength) {
+        throw new Error(`${field} exceeds max length ${maxLength}`);
+    }
+}
+function assertNonNegative(value, field, integerOnly = true) {
+    if (typeof value !== "number" || Number.isNaN(value) || value < 0) {
+        throw new Error(`${field} must be a non-negative number`);
+    }
+    if (integerOnly && !Number.isInteger(value)) {
+        throw new Error(`${field} must be an integer`);
+    }
+}
+function normalizeTimestamp(value) {
+    const d = value instanceof Date ? value : new Date(value);
+    if (Number.isNaN(d.getTime())) {
+        throw new Error("timestamp must be a valid ISO-8601 datetime");
+    }
+    return d.toISOString();
+}
+function normalizeTags(tags) {
+    if (!isObject(tags)) {
+        throw new Error("tags must be an object");
+    }
+    const forbidden = containsForbiddenKeys(tags);
+    if (forbidden) {
+        throw new Error(`tags contains forbidden key: ${forbidden}`);
+    }
+    const normalized = {};
+    for (const [key, value] of Object.entries(tags)) {
+        const isKnown = ALLOWED_TAGS.has(key);
+        const isCustom = CUSTOM_TAG_KEY_PATTERN.test(key) && !FORBIDDEN_KEYS.includes(key);
+        if (!isKnown && !isCustom) {
+            throw new Error(`tags.${key} is not supported (use known tags or lowercase custom keys like team, project_code)`);
+        }
+        if (typeof value === "string") {
+            assertNonEmptyString(value, `tags.${key}`);
+            const normalizedValue = value.trim();
+            if (normalizedValue.length > MAX_TAG_VALUE_LENGTH) {
+                throw new Error(`tags.${key} exceeds max length ${MAX_TAG_VALUE_LENGTH}`);
+            }
+            normalized[key] = normalizedValue;
+            continue;
+        }
+        if (Array.isArray(value)) {
+            if (value.length === 0) {
+                throw new Error(`tags.${key} array must not be empty`);
+            }
+            if (value.length > MAX_TAG_ARRAY_ITEMS) {
+                throw new Error(`tags.${key} has too many values (max ${MAX_TAG_ARRAY_ITEMS})`);
+            }
+            const normalizedArray = value.map((item, idx) => {
+                if (typeof item !== "string" || item.trim().length === 0) {
+                    throw new Error(`tags.${key}[${idx}] must be a non-empty string`);
+                }
+                const normalizedItem = item.trim();
+                if (normalizedItem.length > MAX_TAG_VALUE_LENGTH) {
+                    throw new Error(`tags.${key}[${idx}] exceeds max length ${MAX_TAG_VALUE_LENGTH}`);
+                }
+                return normalizedItem;
+            });
+            normalized[key] = normalizedArray;
+            continue;
+        }
+        throw new Error(`tags.${key} must be a string or string[]`);
+    }
+    if (Object.keys(normalized).length > MAX_TAGS_PER_EVENT) {
+        throw new Error(`tags has too many keys (max ${MAX_TAGS_PER_EVENT})`);
+    }
+    for (const key of REQUIRED_TAGS) {
+        const requiredValue = normalized[key];
+        if (typeof requiredValue !== "string" || requiredValue.length === 0) {
+            throw new Error(`tags.${key} is required`);
+        }
+    }
+    return normalized;
+}
+function normalizeEvent(event) {
+    if (!isObject(event)) {
+        throw new Error("event must be an object");
+    }
+    const forbidden = containsForbiddenKeys(event);
+    if (forbidden) {
+        throw new Error(`event contains forbidden field: ${forbidden}`);
+    }
+    assertNonEmptyString(event.provider, "provider");
+    assertNonEmptyString(event.model, "model");
+    assertNonNegative(event.inputTokens, "inputTokens", true);
+    assertNonNegative(event.outputTokens, "outputTokens", true);
+    assertNonNegative(event.latencyMs, "latencyMs", true);
+    if (event.costUsd !== undefined) {
+        assertNonNegative(event.costUsd, "costUsd", false);
+    }
+    if (event.eventId !== undefined) {
+        assertNonEmptyString(event.eventId, "eventId");
+    }
+    if (event.resolvedModel !== undefined) {
+        assertNonEmptyString(event.resolvedModel, "resolvedModel");
+    }
+    if (event.inputTokensCached !== undefined) {
+        assertNonNegative(event.inputTokensCached, "inputTokensCached", true);
+    }
+    if (event.inputTokensCacheWrite !== undefined) {
+        assertNonNegative(event.inputTokensCacheWrite, "inputTokensCacheWrite", true);
+    }
+    if (event.thinkingTokens !== undefined) {
+        assertNonNegative(event.thinkingTokens, "thinkingTokens", true);
+    }
+    if (event.cacheTtl !== undefined && event.cacheTtl !== "5m" && event.cacheTtl !== "1h") {
+        throw new Error("cacheTtl must be \"5m\" or \"1h\"");
+    }
+    if (event.webSearchCount !== undefined) {
+        assertNonNegative(event.webSearchCount, "webSearchCount", true);
+    }
+    if (event.webFetchCount !== undefined) {
+        assertNonNegative(event.webFetchCount, "webFetchCount", true);
+    }
+    if (event.isBatchApi !== undefined && typeof event.isBatchApi !== "boolean") {
+        throw new Error("isBatchApi must be a boolean");
+    }
+    if (event.isFastMode !== undefined && typeof event.isFastMode !== "boolean") {
+        throw new Error("isFastMode must be a boolean");
+    }
+    return {
+        ...(event.eventId ? { event_id: event.eventId.trim() } : {}),
+        provider: event.provider.trim().toLowerCase(),
+        model: event.model.trim(),
+        ...(event.resolvedModel ? { resolved_model: event.resolvedModel.trim() } : {}),
+        input_tokens: event.inputTokens,
+        output_tokens: event.outputTokens,
+        ...(event.inputTokensCached !== undefined ? { input_tokens_cached: event.inputTokensCached } : {}),
+        ...(event.inputTokensCacheWrite !== undefined ? { input_tokens_cache_write: event.inputTokensCacheWrite } : {}),
+        ...(event.thinkingTokens !== undefined ? { thinking_tokens: event.thinkingTokens } : {}),
+        ...(event.cacheTtl ? { cache_ttl: event.cacheTtl } : {}),
+        ...(event.webSearchCount !== undefined ? { web_search_count: event.webSearchCount } : {}),
+        ...(event.webFetchCount !== undefined ? { web_fetch_count: event.webFetchCount } : {}),
+        ...(event.isBatchApi ? { is_batch_api: true } : {}),
+        ...(event.isFastMode ? { is_fast_mode: true } : {}),
+        latency_ms: event.latencyMs,
+        ...(event.costUsd !== undefined ? { cost_usd: event.costUsd } : {}),
+        timestamp: normalizeTimestamp(event.timestamp),
+        tags: normalizeTags(event.tags)
+    };
+}

package/dist/wrap-anthropic.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Wraps an Anthropic client so every messages.create() call is
+ * automatically tracked. Returns the original response unchanged.
+ *
+ * Usage:
+ *   import { init, wrapAnthropic } from "@aispendguard/sdk";
+ *   import Anthropic from "@anthropic-ai/sdk";
+ *
+ *   init({ apiKey: "asg_...", defaultTags: { feature: "chat", route: "/api/chat" } });
+ *   const anthropic = wrapAnthropic(new Anthropic());
+ *
+ *   // Automatically tracked:
+ *   const msg = await anthropic.messages.create({ model: "claude-sonnet-4-20250514", ... });
+ */
+export declare function wrapAnthropic<T extends object>(client: T): T;

package/dist/wrap-anthropic.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrapAnthropic = wrapAnthropic;
+const anthropic_1 = require("./anthropic");
+const index_1 = require("./index");
+/**
+ * Wraps an Anthropic client so every messages.create() call is
+ * automatically tracked. Returns the original response unchanged.
+ *
+ * Usage:
+ *   import { init, wrapAnthropic } from "@aispendguard/sdk";
+ *   import Anthropic from "@anthropic-ai/sdk";
+ *
+ *   init({ apiKey: "asg_...", defaultTags: { feature: "chat", route: "/api/chat" } });
+ *   const anthropic = wrapAnthropic(new Anthropic());
+ *
+ *   // Automatically tracked:
+ *   const msg = await anthropic.messages.create({ model: "claude-sonnet-4-20250514", ... });
+ */
+function wrapAnthropic(client) {
+    const messages = client.messages;
+    if (!messages || typeof messages !== "object")
+        return client;
+    const originalCreate = messages.create;
+    if (typeof originalCreate !== "function")
+        return client;
+    messages.create = async function wrappedCreate(params, ...rest) {
+        const start = Date.now();
+        const result = await originalCreate.call(this, params, ...rest);
+        const latencyMs = Date.now() - start;
+        try {
+            const client = getClientSafe();
+            if (!client)
+                return result;
+            const res = result;
+            const model = params.model ?? "unknown";
+            const resolvedModel = typeof res.model === "string" ? res.model : undefined;
+            const usage = res.usage;
+            const asgOpts = params;
+            const tags = mergeTags(client.defaultTags, asgOpts.asgTags, model);
+            const event = (0, anthropic_1.createAnthropicUsageEvent)({
+                model,
+                resolvedModel,
+                usage: usage,
+                latencyMs,
+                tags,
+            });
+            client.trackUsage(event).catch(logError);
+        }
+        catch {
+            // Never break user code
+        }
+        return result;
+    };
+    return client;
+}
+function mergeTags(defaults, overrides, model) {
+    return {
+        task_type: "chat",
+        feature: "default",
+        route: "default",
+        ...defaults,
+        ...overrides,
+        source: "auto-wrap",
+        model,
+    };
+}
+function getClientSafe() {
+    try {
+        return (0, index_1.getClient)();
+    }
+    catch {
+        return null;
+    }
+}
+function logError(err) {
+    console.warn(`[aispendguard-sdk] auto-wrap tracking failed: ${err instanceof Error ? err.message : String(err)}`);
+}