@vantinelai/node-sdk 0.4.5

package/dist/client.js

@@ -0,0 +1,431 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MODEL_PRICING = exports.VantinelClient = void 0;
+exports.estimateCostFromTokens = estimateCostFromTokens;
+exports.estimateCostFromText = estimateCostFromText;
+exports.estimateTokens = estimateTokens;
+const axios_1 = __importDefault(require("axios"));
+const security_1 = require("./security");
+/**
+ * Rough token estimation: ~4 characters per token.
+ */
+function estimateTokens(text) {
+    return Math.ceil(text.length / 4);
+}
+const DEFAULT_COST_PER_1K_TOKENS = 0.01;
+/**
+ * Model pricing per 1k tokens (input, output, cache_read) in USD.
+ */
+const MODEL_PRICING = {
+    // OpenAI 2026 Models
+    'gpt-5.2': { input: 0.00175, output: 0.014 },
+    'gpt-5.2-pro': { input: 0.021, output: 0.168 },
+    'gpt-5-mini': { input: 0.00025, output: 0.002 },
+    // OpenAI Legacy
+    'gpt-4o': { input: 0.0025, output: 0.010 },
+    'gpt-4o-2024-05-13': { input: 0.005, output: 0.015 },
+    'gpt-4o-2024-08-06': { input: 0.0025, output: 0.010 },
+    'gpt-4o-2024-11-20': { input: 0.0025, output: 0.010 },
+    'gpt-4o-mini': { input: 0.00015, output: 0.0006 },
+    'o1': { input: 0.015, output: 0.060 },
+    'o3-mini': { input: 0.0011, output: 0.0044 },
+    'gpt-4-turbo': { input: 0.01, output: 0.03 },
+    // Anthropic 2026 Models
+    'claude-4.6-opus': { input: 0.005, output: 0.025 },
+    'claude-4.6-sonnet': { input: 0.003, output: 0.015 },
+    'claude-4.5-opus': { input: 0.005, output: 0.025 },
+    'claude-4.5-sonnet': { input: 0.003, output: 0.015 },
+    'claude-4.5-haiku': { input: 0.001, output: 0.005 },
+    // Anthropic Legacy
+    'claude-3-5-sonnet-20241022': { input: 0.003, output: 0.015 },
+    'claude-3-5-haiku-20241022': { input: 0.0008, output: 0.004 },
+    'claude-3-opus': { input: 0.015, output: 0.075 },
+    // Google Models 2026
+    'gemini-3.1-pro': { input: 0.002, output: 0.012 },
+    'gemini-3.0-pro': { input: 0.002, output: 0.012 },
+    'gemini-3-flash': { input: 0.0005, output: 0.003 },
+    'gemini-2.5-flash': { input: 0.000075, output: 0.0003 },
+    'gemini-2.0-flash': { input: 0.0001, output: 0.0004 },
+    'gemini-1.5-pro': { input: 0.00125, output: 0.005 },
+};
+exports.MODEL_PRICING = MODEL_PRICING;
+function estimateCostFromText(text) {
+    const tokens = estimateTokens(text);
+    return (tokens / 1000) * DEFAULT_COST_PER_1K_TOKENS;
+}
+function estimateCostFromTokens(model, inputTokens, outputTokens, cachedTokens = 0) {
+    const pricing = MODEL_PRICING[model];
+    if (pricing) {
+        const regularInputTokens = Math.max(0, inputTokens - cachedTokens);
+        const cacheReadPrice = pricing.cache_read !== undefined ? pricing.cache_read : pricing.input * 0.5;
+        return (regularInputTokens / 1000) * pricing.input +
+            (cachedTokens / 1000) * cacheReadPrice +
+            (outputTokens / 1000) * pricing.output;
+    }
+    return ((inputTokens + outputTokens) / 1000) * DEFAULT_COST_PER_1K_TOKENS;
+}
+class VantinelClient {
+    constructor(config) {
+        this.config = config;
+        this.batchQueue = [];
+        this.flushTimer = null;
+        this.globalMetadata = {};
+        const validatedUrl = (0, security_1.validateCollectorUrl)(config.collectorUrl || 'http://localhost:8000');
+        this.client = axios_1.default.create({
+            baseURL: validatedUrl,
+            timeout: 2000,
+        });
+        const interval = config.flushInterval ?? 0;
+        if (interval > 0) {
+            this.flushTimer = setInterval(() => {
+                this.flush().catch((err) => {
+                    console.warn('[Vantinel] Background flush failed:', err.message);
+                });
+            }, interval);
+            // Prevent the timer from keeping the Node.js process alive
+            if (this.flushTimer.unref) {
+                this.flushTimer.unref();
+            }
+        }
+    }
+    setGlobalMetadata(metadata) {
+        this.globalMetadata = { ...this.globalMetadata, ...metadata };
+    }
+    mergeGlobalMetadata(event) {
+        if (Object.keys(this.globalMetadata).length === 0)
+            return event;
+        return {
+            ...event,
+            metadata: { ...this.globalMetadata, ...(event.metadata ?? {}) },
+        };
+    }
+    async sendWithRetry(events) {
+        const maxRetries = this.config.retry?.maxRetries ?? 0;
+        const backoffMs = this.config.retry?.backoffMs ?? 100;
+        const payload = events.length === 1 ? events[0] : events;
+        const body = JSON.stringify(payload);
+        const timestamp = Date.now();
+        const nonce = (0, security_1.generateNonce)();
+        const signature = (0, security_1.hmacSign)(this.config.apiKey || '', timestamp, body, nonce);
+        const headers = {
+            'Content-Type': 'application/json',
+            'X-Vantinel-API-Key': this.config.apiKey || '',
+            'X-Vantinel-Signature': signature,
+            'X-Vantinel-Timestamp': String(timestamp),
+            'X-Vantinel-Nonce': nonce,
+            'X-Vantinel-Client': this.config.clientId || '',
+        };
+        let lastError = null;
+        for (let attempt = 0; attempt <= maxRetries; attempt++) {
+            if (attempt > 0) {
+                await new Promise((resolve) => setTimeout(resolve, backoffMs * attempt));
+            }
+            try {
+                const response = await this.client.post('/v1/events', body, { headers });
+                if (Array.isArray(payload)) {
+                    // For batch sends, use the server's aggregate decision if available
+                    const data = response.data;
+                    if (data && typeof data.decision === 'string') {
+                        return data;
+                    }
+                    // If server returns an array of decisions, use the most restrictive one
+                    if (Array.isArray(data)) {
+                        const dominated = data.find((d) => d.decision === 'block');
+                        if (dominated)
+                            return dominated;
+                        const approval = data.find((d) => d.decision === 'require_approval');
+                        if (approval)
+                            return approval;
+                    }
+                    return { decision: 'allow' };
+                }
+                return response.data;
+            }
+            catch (error) {
+                const status = error.response?.status;
+                // Retry on network errors or 5xx
+                if (!status || status >= 500) {
+                    lastError = error;
+                    continue;
+                }
+                // Non-retryable error (4xx etc.)
+                console.warn('[Vantinel] Non-retryable error from collector:', error.message);
+                if (this.config.failMode === 'closed') {
+                    return { decision: 'block', message: 'Vantinel Gateway returned non-retryable error and failMode is closed.' };
+                }
+                return { decision: 'allow' };
+            }
+        }
+        console.warn('[Vantinel] Failed to contact collector after retries:', lastError?.message);
+        if (this.config.failMode === 'closed') {
+            return { decision: 'block', message: 'Vantinel Gateway is unreachable and failMode is closed.' };
+        }
+        return { decision: 'allow' };
+    }
+    /**
+     * Send an event to the collector.
+     * Cost is only included if explicitly set on the event.
+     */
+    async sendEvent(event) {
+        const enriched = this.mergeGlobalMetadata(event);
+        if (this.config.dryRun) {
+            console.log('[Vantinel DryRun] Event:', enriched);
+            return { decision: 'allow' };
+        }
+        const batchSize = this.config.batchSize ?? 1;
+        if (batchSize <= 1) {
+            // No batching — send immediately
+            return this.sendWithRetry([enriched]);
+        }
+        // Batching mode — buffer and flush when full
+        return new Promise((resolve) => {
+            this.batchQueue.push(enriched);
+            if (this.batchQueue.length >= batchSize) {
+                const batch = this.batchQueue.splice(0, batchSize);
+                this.sendWithRetry(batch)
+                    .then((decision) => resolve(decision))
+                    .catch(() => resolve(this.config.failMode === 'closed' ? { decision: 'block', message: 'Failed to send batch and failMode is closed.' } : { decision: 'allow' }));
+            }
+            else {
+                // Resolve immediately with allow; batch will be sent when full or on flush()
+                resolve({ decision: 'allow' });
+            }
+        });
+    }
+    /**
+     * Wrap a tool function — automatically measures latency and tracks it.
+     * This is the recommended way to use Vantinel.
+     *
+     * Cost is only reported if you explicitly provide it (e.g., from your LLM provider's usage data).
+     * Latency is always automatically measured.
+     *
+     * @example
+     * const result = await client.wrap('search_db', '{"query":"test"}', async () => {
+     *   return await searchDatabase('test');
+     * });
+     */
+    async wrap(toolName, toolArgs, fn, options) {
+        const { createHash } = await Promise.resolve().then(() => __importStar(require('crypto')));
+        const hash = createHash('sha256').update(`${toolName}:${toolArgs}`).digest('hex').slice(0, 32);
+        const sessionId = options?.sessionId || `session_${Date.now()}`;
+        // Pre-check with the gateway
+        const preEvent = {
+            event_type: 'tool_call',
+            session_id: sessionId,
+            agent_id: this.config.agentId,
+            tool_name: toolName,
+            tool_args_hash: hash,
+            timestamp: Date.now(),
+            estimated_cost: options?.estimatedCost,
+            trace_id: options?.traceId,
+        };
+        const decision = await this.sendEvent(preEvent);
+        if (decision.decision === 'block') {
+            throw new Error(`[Vantinel] Tool call blocked: ${toolName} — ${decision.message || 'Policy violation'}`);
+        }
+        // Execute and time
+        const startTime = process.hrtime.bigint();
+        try {
+            const result = await fn();
+            const latencyMs = Number(process.hrtime.bigint() - startTime) / 1000000;
+            // Send completion with latency
+            const completionEvent = {
+                ...preEvent,
+                latency_ms: latencyMs,
+                timestamp: Date.now(),
+            };
+            await this.sendEvent(completionEvent).catch(() => { });
+            return result;
+        }
+        catch (err) {
+            const latencyMs = Number(process.hrtime.bigint() - startTime) / 1000000;
+            // Report error with latency
+            const errorEvent = {
+                ...preEvent,
+                event_type: 'tool_error',
+                latency_ms: latencyMs,
+                timestamp: Date.now(),
+                metadata: {
+                    error_message: err instanceof Error ? err.message : String(err),
+                },
+            };
+            await this.sendEvent(errorEvent).catch(() => { });
+            throw err;
+        }
+    }
+    /**
+     * Auto-instrument an OpenAI client.
+     * This monkey-patches `chat.completions.create` to automatically intercept calls,
+     * measure latency, extract exact token usage from the response, and calculate true cost.
+     *
+     * @param openaiClient - The instantiated OpenAI client (e.g., `new OpenAI()`)
+     * @param options - Optional configuration for the intercepted calls
+     * @returns The patched OpenAI client
+     */
+    wrapOpenAI(openaiClient, options) {
+        if (!openaiClient?.chat?.completions?.create) {
+            console.warn('[Vantinel] Provided client does not look like an OpenAI client. wrapOpenAI failed.');
+            return openaiClient;
+        }
+        const originalCreate = openaiClient.chat.completions.create.bind(openaiClient.chat.completions);
+        openaiClient.chat.completions.create = async (body, reqOptions) => {
+            const toolName = 'openai_chat';
+            const argsText = typeof body === 'string' ? body : JSON.stringify(body);
+            const sessionId = options?.sessionId || `session_${Date.now()}`;
+            const { createHash } = await Promise.resolve().then(() => __importStar(require('crypto')));
+            const hash = createHash('sha256').update(`${toolName}:${argsText}`).digest('hex').slice(0, 32);
+            const isStream = body?.stream === true || reqOptions?.stream === true;
+            // Clone to avoid mutating the caller's object
+            const modifiedBody = isStream && !body.stream_options
+                ? { ...body, stream_options: { include_usage: true } }
+                : body;
+            const preEvent = {
+                event_type: 'tool_call',
+                session_id: sessionId,
+                agent_id: this.config.agentId,
+                tool_name: toolName,
+                tool_args_hash: hash,
+                timestamp: Date.now(),
+                trace_id: options?.traceId,
+            };
+            const decision = await this.sendEvent(preEvent);
+            if (decision.decision === 'block') {
+                throw new Error(`[Vantinel] Tool call blocked: ${toolName} — ${decision.message || 'Policy violation'}`);
+            }
+            const startTime = process.hrtime.bigint();
+            try {
+                const response = await originalCreate(modifiedBody, reqOptions);
+                if (isStream) {
+                    const self = this;
+                    async function* wrapper() {
+                        let finalUsage = null;
+                        let finalModel = body.model;
+                        try {
+                            for await (const chunk of response) {
+                                if (chunk.usage)
+                                    finalUsage = chunk.usage;
+                                if (chunk.model)
+                                    finalModel = chunk.model;
+                                yield chunk;
+                            }
+                        }
+                        finally {
+                            const latencyMs = Number(process.hrtime.bigint() - startTime) / 1000000;
+                            let estimatedCost = undefined;
+                            if (finalUsage && finalModel) {
+                                const cachedTokens = finalUsage.prompt_tokens_details?.cached_tokens || 0;
+                                estimatedCost = estimateCostFromTokens(finalModel, finalUsage.prompt_tokens || 0, finalUsage.completion_tokens || 0, cachedTokens);
+                            }
+                            const completionEvent = {
+                                ...preEvent,
+                                latency_ms: latencyMs,
+                                estimated_cost: estimatedCost,
+                                timestamp: Date.now(),
+                            };
+                            self.sendEvent(completionEvent).catch(() => { });
+                        }
+                    }
+                    return wrapper();
+                }
+                const latencyMs = Number(process.hrtime.bigint() - startTime) / 1000000;
+                // Calculate exact cost from the actual usage reported by OpenAI!
+                let estimatedCost = undefined;
+                if (response.usage && response.model) {
+                    const cachedTokens = response.usage.prompt_tokens_details?.cached_tokens || 0;
+                    estimatedCost = estimateCostFromTokens(response.model, response.usage.prompt_tokens || 0, response.usage.completion_tokens || 0, cachedTokens);
+                }
+                const completionEvent = {
+                    ...preEvent,
+                    latency_ms: latencyMs,
+                    estimated_cost: estimatedCost,
+                    timestamp: Date.now(),
+                };
+                await this.sendEvent(completionEvent).catch(() => { });
+                return response;
+            }
+            catch (err) {
+                const latencyMs = Number(process.hrtime.bigint() - startTime) / 1000000;
+                const errorEvent = {
+                    ...preEvent,
+                    event_type: 'tool_error',
+                    latency_ms: latencyMs,
+                    timestamp: Date.now(),
+                    metadata: {
+                        error_message: err instanceof Error ? err.message : String(err),
+                    },
+                };
+                await this.sendEvent(errorEvent).catch(() => { });
+                throw err;
+            }
+        };
+        return openaiClient;
+    }
+    /**
+     * Gracefully shut down the client: flush pending events and clear timers.
+     */
+    async destroy() {
+        if (this.flushTimer) {
+            clearInterval(this.flushTimer);
+            this.flushTimer = null;
+        }
+        await this.flush();
+    }
+    async flush() {
+        if (this.batchQueue.length === 0)
+            return;
+        const batch = this.batchQueue.splice(0, this.batchQueue.length);
+        try {
+            await this.sendWithRetry(batch);
+        }
+        catch {
+            // Errors are already logged inside sendWithRetry
+        }
+    }
+    async ping() {
+        const start = Date.now();
+        try {
+            await this.client.get('/health');
+            return { ok: true, latencyMs: Date.now() - start };
+        }
+        catch {
+            return { ok: false, latencyMs: Date.now() - start };
+        }
+    }
+}
+exports.VantinelClient = VantinelClient;

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * from './client';
+export * from './monitor';
+export { validateCollectorUrl, redactApiKey } from './security';
+export { patchOpenAIAgents, VantinelTracingProcessor } from './integrations/openai-agents';
+export { wrapAnthropic } from './integrations/anthropic';

package/dist/index.js

@@ -0,0 +1,28 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrapAnthropic = exports.VantinelTracingProcessor = exports.patchOpenAIAgents = exports.redactApiKey = exports.validateCollectorUrl = void 0;
+__exportStar(require("./client"), exports);
+__exportStar(require("./monitor"), exports);
+var security_1 = require("./security");
+Object.defineProperty(exports, "validateCollectorUrl", { enumerable: true, get: function () { return security_1.validateCollectorUrl; } });
+Object.defineProperty(exports, "redactApiKey", { enumerable: true, get: function () { return security_1.redactApiKey; } });
+// Framework integrations
+var openai_agents_1 = require("./integrations/openai-agents");
+Object.defineProperty(exports, "patchOpenAIAgents", { enumerable: true, get: function () { return openai_agents_1.patchOpenAIAgents; } });
+Object.defineProperty(exports, "VantinelTracingProcessor", { enumerable: true, get: function () { return openai_agents_1.VantinelTracingProcessor; } });
+var anthropic_1 = require("./integrations/anthropic");
+Object.defineProperty(exports, "wrapAnthropic", { enumerable: true, get: function () { return anthropic_1.wrapAnthropic; } });

package/dist/integrations/anthropic.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Anthropic SDK integration for Vantinel.
+ *
+ * Usage:
+ *   import Anthropic from '@anthropic-ai/sdk';
+ *   import { VantinelClient } from '@vantinelai/node-sdk';
+ *   import { wrapAnthropic } from '@vantinelai/node-sdk/integrations/anthropic';
+ *
+ *   const client = new VantinelClient({ apiKey: '...', clientId: '...' });
+ *   const anthropic = wrapAnthropic(client, new Anthropic());
+ *
+ *   const response = await anthropic.messages.create({
+ *     model: 'claude-sonnet-4-6',
+ *     max_tokens: 1024,
+ *     messages: [{ role: 'user', content: 'Hello' }],
+ *   });
+ */
+import type { VantinelClient } from '../client';
+interface AnthropicUsage {
+    input_tokens?: number;
+    output_tokens?: number;
+    cache_creation_input_tokens?: number;
+    cache_read_input_tokens?: number;
+}
+interface AnthropicMessage {
+    role: string;
+    content: unknown;
+}
+interface AnthropicCreateParams {
+    model: string;
+    messages: AnthropicMessage[];
+    stream?: boolean;
+    max_tokens?: number;
+    [key: string]: unknown;
+}
+interface AnthropicResponse {
+    usage?: AnthropicUsage;
+    stop_reason?: string;
+    content?: Array<{
+        type: string;
+        name?: string;
+    }>;
+    [key: string]: unknown;
+}
+interface AnthropicClient {
+    messages: {
+        create(params: AnthropicCreateParams): Promise<AnthropicResponse>;
+        [key: string]: unknown;
+    };
+    [key: string]: unknown;
+}
+/**
+ * Wrap an Anthropic client to auto-monitor all messages.create() calls.
+ *
+ * @param vantinelClient - VantinelClient instance
+ * @param anthropicClient - anthropic.Anthropic() instance
+ * @param options - Optional session/agent configuration
+ * @returns The patched Anthropic client
+ */
+export declare function wrapAnthropic(vantinelClient: VantinelClient, anthropicClient: AnthropicClient, options?: {
+    sessionId?: string;
+    agentId?: string;
+}): AnthropicClient;
+export {};

package/dist/integrations/anthropic.js

@@ -0,0 +1,138 @@
+"use strict";
+/**
+ * Anthropic SDK integration for Vantinel.
+ *
+ * Usage:
+ *   import Anthropic from '@anthropic-ai/sdk';
+ *   import { VantinelClient } from '@vantinelai/node-sdk';
+ *   import { wrapAnthropic } from '@vantinelai/node-sdk/integrations/anthropic';
+ *
+ *   const client = new VantinelClient({ apiKey: '...', clientId: '...' });
+ *   const anthropic = wrapAnthropic(client, new Anthropic());
+ *
+ *   const response = await anthropic.messages.create({
+ *     model: 'claude-sonnet-4-6',
+ *     max_tokens: 1024,
+ *     messages: [{ role: 'user', content: 'Hello' }],
+ *   });
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrapAnthropic = wrapAnthropic;
+const crypto = __importStar(require("crypto"));
+const client_1 = require("../client");
+function buildArgsHash(model, messages) {
+    return crypto
+        .createHash('sha256')
+        .update(JSON.stringify({ model, messages_count: messages.length, first_msg: messages[0]?.content }))
+        .digest('hex')
+        .slice(0, 32);
+}
+function extractCost(model, usage) {
+    if (!usage)
+        return undefined;
+    const inputTokens = (usage.input_tokens ?? 0) + (usage.cache_creation_input_tokens ?? 0);
+    const outputTokens = usage.output_tokens ?? 0;
+    const cachedTokens = usage.cache_read_input_tokens ?? 0;
+    return (0, client_1.estimateCostFromTokens)(model, inputTokens + cachedTokens, outputTokens, cachedTokens);
+}
+/**
+ * Wrap an Anthropic client to auto-monitor all messages.create() calls.
+ *
+ * @param vantinelClient - VantinelClient instance
+ * @param anthropicClient - anthropic.Anthropic() instance
+ * @param options - Optional session/agent configuration
+ * @returns The patched Anthropic client
+ */
+function wrapAnthropic(vantinelClient, anthropicClient, options) {
+    const originalCreate = anthropicClient.messages.create.bind(anthropicClient.messages);
+    const sessionId = options?.sessionId ?? `anthropic_${Date.now()}`;
+    anthropicClient.messages.create = async (params) => {
+        const { model, messages } = params;
+        const toolName = `anthropic_messages_${model}`;
+        const argsHash = buildArgsHash(model, messages);
+        // Pre-call: send event to get decision
+        let decision;
+        try {
+            const resp = await vantinelClient.sendEvent({
+                event_type: 'tool_call',
+                tool_name: toolName,
+                tool_args_hash: argsHash,
+                session_id: sessionId,
+                agent_id: options?.agentId,
+                timestamp: Date.now(),
+                metadata: { model, messages_count: messages.length, framework: 'anthropic' },
+            });
+            decision = resp?.decision;
+        }
+        catch {
+            // Fail open: don't block the call if Vantinel is unavailable
+        }
+        if (decision === 'block') {
+            throw new Error(`Vantinel blocked Anthropic call: ${toolName}`);
+        }
+        const startTime = Date.now();
+        const result = await originalCreate(params);
+        const latencyMs = Date.now() - startTime;
+        const usage = result.usage;
+        const cost = extractCost(model, usage);
+        const toolUses = result.content
+            ?.filter((b) => b.type === 'tool_use')
+            .map((b) => b.name)
+            .filter(Boolean) ?? [];
+        // Post-call telemetry (fire-and-forget)
+        void vantinelClient.sendEvent({
+            event_type: 'tool_result',
+            tool_name: toolName,
+            tool_args_hash: argsHash,
+            session_id: sessionId,
+            agent_id: options?.agentId,
+            timestamp: Date.now(),
+            estimated_cost: cost,
+            latency_ms: latencyMs,
+            metadata: {
+                model,
+                messages_count: messages.length,
+                framework: 'anthropic',
+                stop_reason: result.stop_reason,
+                tool_uses: toolUses,
+                input_tokens: usage?.input_tokens,
+                output_tokens: usage?.output_tokens,
+            },
+        }).catch(() => { });
+        return result;
+    };
+    return anthropicClient;
+}

package/dist/integrations/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Vantinel integrations for major AI frameworks.
+ */
+export { patchOpenAIAgents, VantinelTracingProcessor } from './openai-agents';
+export { wrapAnthropic } from './anthropic';