vibezcheck 0.2.0 → 0.4.0

package/README.md

@@ -1,269 +1,203 @@
 # ⚡ vibezcheck
 
-> **The 1-line Stripe Billing & Token Metering engine for LLMs.**  
-> Track tokens, compute real-time dollar costs, and bill customers with 0ms added latency.
+> **Give your AI app a financial mind.**  
+> The declarative 1-line Stripe Billing and Token Metering engine for LLMs. Measure tokens, compute real-time dollar costs, and bill customers with **0ms added latency**.
 
 [![npm version](https://img.shields.io/npm/v/vibezcheck.svg)](https://npmjs.org/package/vibezcheck)
 [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
 [![TypeScript](https://img.shields.io/badge/TypeScript-Strict-blue.svg)](https://www.typescriptlang.org/)
+[![Tests](https://img.shields.io/badge/Tests-31%20Passed-brightgreen.svg)]()
 
 ---
 
-## 🚀 Why vibezcheck?
+## 🍌 The Electric Meter for Artificial Intelligence
 
-* **⚡ 0ms Added Latency**: Streams pass straight through to the browser with zero buffering.
-* **🧠 Reasoning & Thinking Token Aware**: Accurately tracks hidden reasoning tokens in GPT-5, o1/o3, Claude 3.7 Thinking, and Gemini 3.7 Thoughts.
-* **💰 Built-in Cost Engine**: Calculates exact USD inference costs out of the box with prompt caching discounts.
-* **🆓 Zero-Config Local Mode**: Works 100% free in development with no Stripe account needed.
-* **💳 1-Line Stripe Billing**: Turn an AI prototype into a live, revenue-generating SaaS in 1 line of code.
+When you turn on the lights in your bedroom, your electric meter spins. When users prompt your AI, **VibezCheck** is the smart meter that counts every word and hidden thought — converting it into pennies with Stripe so your app actually looks out for your margins.
+
+### 🛡️ Sane Defaults (Zero Configuration Required)
+* **⚡ 0ms Added Latency**: Streams pass directly to your user's browser with zero intermediate proxy buffering.
+* **🛡️ Default $0.50 Fuse Box**: Automatically prevents runaway loops without requiring manual ceilings.
+* **🛟 In-Flight Abort Trapper**: Captures and bills partial tokens even if a user closes their browser tab mid-stream.
+* **🏷️ Automatic 85% Prompt Cache Discounts**: Detects cache hits on Claude 3.7, GPT-4o, and DeepSeek and passes real savings through.
+* **🚀 Serverless Lifecycle Protection**: Seamlessly keeps serverless containers alive until telemetry is acknowledged.
+* **💰 1-Line Profit Margins**: Turn wholesale provider costs into guaranteed net profit with `pricing: { margin: 1.5 }`.
+* **💳 Prepaid & Postpaid**: Choose between monthly metered invoices or zero-debt credit wallets.
+* **🧠 Reasoning Token Aware**: Captures hidden thinking tokens in o3-mini and Claude 3.7 Thinking.
+* **🆓 Free Vibe Mode**: Works 100% out of the box in local development with no Stripe account required.
 
 ---
 
 ## 📦 Installation
 
 ```bash
-npm install vibezcheck stripe
-# or
-pnpm add vibezcheck stripe
+npm install vibezcheck ai @ai-sdk/openai stripe
 ```
 
 ---
 
-## 🎯 The 2 Core Features
-
----
-
-### Feature 1: Local Token & Cost Tracking (Free / No Stripe Required)
+## ⚡ 1. The 60-Second Quickstart
 
-Use this in development or when you want real-time token and USD cost analytics without billing users:
-
-#### 💻 Code:
+### Backend API Route (`app/api/chat/route.ts`)
 ```typescript
-// app/api/chat/route.ts
-import { createMeter } from 'vibezcheck/meter';
-import OpenAI from 'openai';
-
-const openai = new OpenAI();
-
-// 1. Create a meter (no Stripe key required!)
-const meter = createMeter({
-  onUsage: (event) => {
-    console.log(`[vibezcheck] 📊 Model: ${event.model}`);
-    console.log(`Tokens: ${event.usage.totalTokens} (Input: ${event.usage.inputTokens}, Output: ${event.usage.outputTokens}, Reasoning: ${event.usage.reasoningTokens ?? 0})`);
-    console.log(`Inference Cost: $${event.cost.totalUSD.toFixed(6)} USD\n`);
-  },
-});
+import { streamText } from 'ai';
+import { vibezcheck } from 'vibezcheck';
 
 export async function POST(req: Request) {
-  const { messages } = await req.json();
+  const { messages, userEmail = 'alex@company.com' } = await req.json();
 
-  const stream = await openai.chat.completions.create({
-    model: 'gpt-4o',
+  return streamText({
+    // ⚡ 1 Line. All 6 sane defaults run automatically.
+    model: vibezcheck('openai/gpt-4o-mini', { customer: userEmail }),
     messages,
-    stream: true,
-    stream_options: { include_usage: true },
-  });
-
-  // 2. Wrap stream - passes chunks directly to user with 0ms added delay
-  return new Response(meter.wrapStream(stream));
+  }).toDataStreamResponse();
 }
 ```
 
-#### 🌐 What the Frontend receives:
-```http
-HTTP/1.1 200 OK
-Content-Type: text/plain; charset=utf-8
-Transfer-Encoding: chunked
+### Frontend Chat UI (`app/page.tsx`)
+```tsx
+'use client';
+import { useVibezChat, VibezReceipt, VibezSessionWidget } from 'vibezcheck/react';
 
-Quantum computing uses qubits to perform complex calculations exponentially faster...
-```
+export default function ChatPage() {
+  const { messages, input, handleInputChange, handleSubmit } = useVibezChat();
 
-#### 🖥️ What your Terminal logs:
-```
-[vibezcheck] 📊 Model: openai/gpt-4o
-Tokens: 1,420 (Input: 800, Output: 620, Reasoning: 0)
-Inference Cost: $0.008200 USD
+  return (
+    <main className="max-w-xl mx-auto py-10 px-4 space-y-6">
+      {/* 1. Floating live token & dollar counter */}
+      <VibezSessionWidget position="bottom-right" />
+
+      {/* 2. Messages with micro-receipts */}
+      <div className="space-y-4">
+        {messages.map((m) => (
+          <div key={m.id} className="p-4 rounded-2xl bg-white border border-slate-200">
+            <p className="text-slate-900 text-sm">{m.content}</p>
+
+            {/* Micro-Receipt under assistant answers */}
+            {m.role === 'assistant' && <VibezReceipt message={m} />}
+          </div>
+        ))}
+      </div>
+
+      <form onSubmit={handleSubmit} className="flex gap-2">
+        <input
+          value={input}
+          onChange={handleInputChange}
+          placeholder="Ask a question..."
+          className="flex-1 px-4 py-2 rounded-xl border border-slate-200 text-sm"
+        />
+        <button type="submit" className="px-5 py-2 rounded-xl bg-slate-950 text-white font-bold text-sm">
+          Send
+        </button>
+      </form>
+    </main>
+  );
+}
 ```
 
 ---
 
-### Feature 2: 1-Line Stripe Billing with Vercel AI SDK (`withBilling`)
+## 🛠️ Real-World Implementation Patterns
 
-Use this when you are ready to charge users and protect your margins from heavy reasoning models (GPT-5, Claude 3.7 Thinking):
+### Pattern A: 50% Profit Margin Engine
+Turn wholesale provider costs into guaranteed net profit:
 
-#### 💻 Code:
 ```typescript
-// app/api/chat/route.ts
-import { withBilling } from 'vibezcheck';
-import { openai } from '@ai-sdk/openai';
-import { streamText } from 'ai';
-
-export async function POST(req: Request) {
-  const { messages, userEmail } = await req.json();
-
-  // 1-line wrapper: extracts reasoning tokens & logs meter events to Stripe!
-  const result = streamText({
-    model: withBilling(openai('gpt-5.6-sol'), {
-      customer: userEmail, // e.g. "alex@example.com"
-      stripeApiKey: process.env.STRIPE_SECRET_KEY,
-    }),
-    messages,
-  });
-
-  return result.toDataStreamResponse();
-}
+model: vibezcheck('openai/gpt-4o-mini', {
+  customer: 'sarah@acme.com',
+  pricing: {
+    margin: 1.5,           // 👈 Cost + 50% margin automatically billed to Stripe!
+    minimumChargeUSD: 0.01, // 👈 Minimum charge 1 cent per question
+  },
+})
 ```
 
-#### 🌐 What the Frontend receives:
-Compatible with Vercel's `useChat()` React hook:
-```http
-HTTP/1.1 200 OK
-Content-Type: text/event-stream; charset=utf-8
-x-vercel-ai-data-stream: v1
+---
 
-0:"Here is the "
-0:"solution step by step..."
-d:{"finishReason":"stop","usage":{"promptTokens":1200,"completionTokens":450,"reasoningTokens":350}}
-```
+### Pattern B: Prepaid Credit Wallets (Zero Debt Risk)
+User pre-purchases $10; stream cleanly halts when balance hits $0 without invoice debt:
 
-#### 💳 What Stripe receives in the background:
-1. **Customer Created/Resolved**: Customer `alex@example.com` is automatically created (`cus_Q871xyz`).
-2. **Meter Event Dispatched to Stripe Billing**:
-```json
-{
-  "event_name": "token-billing-tokens",
-  "timestamp": "2026-08-23T10:12:00.000Z",
-  "payload": {
-    "stripe_customer_id": "cus_Q871xyz",
-    "value": "800",
-    "model": "openai/gpt-5.6-sol",
-    "token_type": "output",
-    "is_reasoning": "true"
-  }
-}
+```typescript
+model: vibezcheck('openai/gpt-4o-mini', {
+  customer: 'alex@gmail.com',
+  billing: {
+    mode: 'prepaid', // 👈 Deducts from prepaid credit balance in real time
+  },
+  // Gracefully downshift when credits run low instead of crashing
+  fallbackModelOnBudget: 'openai/gpt-4o-mini',
+})
 ```
-3. **Invoice Updated**: Stripe increments Alex's monthly usage bill or deducts \$0.016 from their prepaid credit balance.
 
 ---
 
-### Also works with Claude 3.7 Sonnet Extended Thinking
+### Pattern C: Frontier Reasoning Models (Claude 3.7 & o3-mini)
+Automatically extracts hidden thinking tokens and applies 85% prompt cache discounts:
 
 ```typescript
-import { createMeter } from 'vibezcheck/meter';
-import Anthropic from '@anthropic-ai/sdk';
-
-const anthropic = new Anthropic();
-const meter = createMeter({ apiKey: process.env.STRIPE_SECRET_KEY });
-
-export async function handleThinkingPrompt(prompt: string, customerId: string) {
-  const stream = await anthropic.messages.create({
-    model: 'claude-3-7-sonnet-20250219',
-    max_tokens: 4000,
-    thinking: { type: 'enabled', budget_tokens: 2000 },
-    messages: [{ role: 'user', content: prompt }],
-    stream: true,
-  });
-
-  // Automatically captures Claude 3.7 thinking tokens and sends to Stripe:
-  return meter.wrapStream(stream, { customerId });
-}
-```
-
-#### 💳 Stripe Meter Event output for Thinking Tokens:
-```json
-{
-  "event_name": "token-billing-tokens",
-  "payload": {
-    "stripe_customer_id": "cus_Q871xyz",
-    "value": "1840",
-    "model": "anthropic/claude-3-7-sonnet",
-    "token_type": "output_thinking"
-  }
-}
+model: vibezcheck('anthropic/claude-3-7-sonnet', {
+  customer: 'alex@company.com',
+  maxCostPerCallUSD: 0.75, // Extended ceiling for multi-minute deep reasoning
+})
 ```
 
 ---
 
-## ⚛️ React & React Native Session Tracking (`vibezcheck/react`)
-
-Track live session tokens and dollar costs directly on the client side with **zero database required**:
+### Pattern D: Unified Agent Tool Call Metering
+Bill external tools (web searches, scrapers, Python sandboxes) and LLM streams into one invoice:
 
-### 1. Wrap your chat app with `<VibezSessionProvider>`:
-```tsx
-import { VibezSessionProvider, VibezSessionWidget } from 'vibezcheck/react';
-
-export default function App() {
-  return (
-    <VibezSessionProvider persist="sessionStorage">
-      <ChatInterface />
-
-      {/* Drop-in floating pill widget showing live session tokens & cost */}
-      <VibezSessionWidget position="bottom-right" showReasoning theme="dark" />
-    </VibezSessionProvider>
-  );
-}
-```
-
-### 2. Auto-hook into Vercel AI SDK (`useChat`):
-```tsx
-import { useChat } from 'ai/react';
-import { useVibezSession, VibezSessionBadge } from 'vibezcheck/react';
-
-export function ChatInterface() {
-  const { recordTurn, sessionUsage, sessionCost } = useVibezSession();
+```typescript
+// app/api/agent/route.ts
+import { generateText, tool } from 'ai';
+import { vibezcheck } from 'vibezcheck';
+import { z } from 'zod';
 
-  const { messages, input, handleSubmit } = useChat({
-    onFinish: (message, { usage }) => {
-      // 1 line: accumulates tokens & calculates real-time USD costs in React state
-      recordTurn({ model: 'gpt-5.6-sol', usage });
+export async function POST(req: Request) {
+  const { prompt, customer = 'alex@company.com' } = await req.json();
+
+  // Create unified customer session
+  const session = vibezcheck.session({ customer });
+
+  const result = await generateText({
+    model: session.model('openai/gpt-4o-mini'),
+    tools: {
+      searchGoogle: tool({
+        description: 'Live Google Search',
+        parameters: z.object({ query: z.string() }),
+        execute: async ({ query }) => {
+          // ⚡ Bill non-LLM tool execution ($0.01) into the same customer balance
+          await session.trackTool('google_search', { costUSD: 0.01 });
+          return `Search results for: ${query}`;
+        },
+      }),
     },
+    prompt,
   });
 
-  return (
-    <div>
-      <header className="flex justify-between items-center">
-        <h2>AI Assistant</h2>
-        <VibezSessionBadge showTokens showCost />
-      </header>
-
-      <MessagesList messages={messages} />
-    </div>
-  );
+  return Response.json(result);
 }
 ```
 
 ---
 
-## 💰 Built-in Model Pricing Registry
-
-`vibezcheck` ships with default rates for all active frontier models:
+### Pattern E: Brand-New Model (1-Line Inline Rate Card)
+Use newly released or fine-tuned models with zero wait for package updates:
 
 ```typescript
-import { calculateCost } from 'vibezcheck/pricing';
+model: vibezcheck('deepseek/deepseek-r2', {
+  rate: { in: 0.20, out: 0.80 }, // $0.20/M in, $0.80/M out
+})
+```
 
-const cost = calculateCost({
-  model: 'claude-3-7-sonnet',
-  inputTokens: 2000,
-  outputTokens: 800,
-  reasoningTokens: 1200, // thinking tokens
-});
+---
 
-console.log(cost);
-```
+## 🎨 React UI Suite (`vibezcheck/react`)
 
-#### 🖥️ Response:
-```json
-{
-  "inputCostUSD": 0.00118,
-  "outputCostUSD": 0.002344,
-  "reasoningCostUSD": 0.003516,
-  "totalCostUSD": 0.007040,
-  "currency": "USD"
-}
-```
+* **`useVibezChat`**: 1-hook drop-in chat streaming with live session cost sync.
+* **`<VibezReceipt />`**: Micro-badge rendered below assistant responses (*"⚡ gpt-4o-mini • 342 tokens • $0.0005 • Verified by VibezCheck"*).
+* **`<VibezSessionWidget />`**: Floating live token & dollar speedometer in the screen corner.
+* **`<VibezBillingModal />`**: Drop-in 1-click Stripe Checkout top-up modal.
 
 ---
 
 ## 📄 License
 
-MIT © [vibezcheck.xyz](https://vibezcheck.xyz)
+MIT © [VibezCheck](https://vibezcheck.app)

package/bin/vibezcheck.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+
+// Forward execution to compiled CLI entrypoint
+require('../dist/cli/index.js');

package/dist/ai-sdk/index.d.mts

@@ -1,12 +1,22 @@
-import { C as CustomerParam, U as UsageEvent } from '../types-CSrSmsd1.mjs';
-import { V as VibezMeter } from '../client-MJ3tl7bz.mjs';
+import { c as CircuitBreakerOptions, C as CustomerParam, B as BillingConfig, P as PricingConfig, d as InlineRateConfig, U as UsageEvent } from '../types-Zbzxg-Ka.mjs';
+import { V as VibezMeter } from '../client--iq93FQg.mjs';
 import 'stripe';
 
-interface WithBillingOptions {
+interface WithBillingOptions extends CircuitBreakerOptions {
     /** Customer email, user ID, or Stripe customer ID */
     customer?: CustomerParam;
     /** Direct Stripe customer ID */
     customerId?: string;
+    /** Billing mode configuration (postpaid vs prepaid) */
+    billing?: BillingConfig;
+    /** Profit margin & minimum charge configuration */
+    pricing?: PricingConfig;
+    /** 1-line inline pricing rate card */
+    rate?: InlineRateConfig;
+    /** Whether to capture tokens if the client aborts or closes tab mid-stream (default: true) */
+    captureOnAbort?: boolean;
+    /** Execution runtime environment (default: 'auto') */
+    runtime?: 'auto' | 'serverless' | 'edge' | 'node';
     /** Stripe API Key override (uses STRIPE_SECRET_KEY env by default) */
     stripeApiKey?: string;
     /** Existing VibezMeter instance (optional) */
@@ -19,16 +29,75 @@ interface WithBillingOptions {
     metadata?: Record<string, string | number | boolean>;
 }
 /**
- * Wraps any Vercel AI SDK LanguageModel (v2 or v3) with automated Stripe billing and token metering.
+ * Wraps any Vercel AI SDK LanguageModel (v2 or v3) with automated Stripe billing, token metering, and agent circuit breakers.
  *
- * @param model - The Vercel AI SDK language model instance (e.g. openai('gpt-5.6-sol'), anthropic('claude-3-7-sonnet'))
- * @param options - Billing & customer configuration
- * @returns Decorated LanguageModel that automatically meters tokens and sends Stripe meter events
+ * Sane Defaults Built-In:
+ * - $0.50 safety ceiling per call (overridable)
+ * - Automatic in-flight token capture on abort
+ * - Automatic prompt caching discount parsing
+ * - Serverless lifecycle preservation
  */
 declare function withBilling<T extends object>(model: T, options?: WithBillingOptions): T;
 /**
- * Alias for withBilling
+ * Convenient alias for withBilling
  */
 declare const meteredModel: typeof withBilling;
 
-export { type WithBillingOptions, meteredModel, withBilling };
+interface VibezCheckModelOptions extends WithBillingOptions {
+    /** OpenAI / AI Gateway API Key override */
+    apiKey?: string;
+    /** AI Gateway / OpenAI Base URL override */
+    baseURL?: string;
+}
+interface VibezSessionOptions {
+    customer?: CustomerParam;
+    stripeApiKey?: string;
+    pricing?: WithBillingOptions['pricing'];
+    billing?: WithBillingOptions['billing'];
+    metadata?: Record<string, string | number | boolean>;
+}
+interface VibezSession {
+    /** Creates a metered model bound to this session customer */
+    model: (modelOrId: any, options?: VibezCheckModelOptions) => any;
+    /** Tracks a non-LLM tool execution cost (e.g. search, scraper, image gen) */
+    trackTool: (name: string, options: {
+        costUSD: number;
+        metadata?: Record<string, any>;
+    }) => Promise<void>;
+    /** Underlying meter instance */
+    meter: VibezMeter;
+}
+/**
+ * Creates or resolves an AI SDK compatible LanguageModel with built-in VibezCheck billing & metering.
+ *
+ * @example
+ * ```typescript
+ * import { generateText, streamText } from 'ai';
+ * import { vibezcheck } from 'vibezcheck';
+ *
+ * // 1. Declarative string model identifier:
+ * const { text } = await generateText({
+ *   model: vibezcheck('openai/gpt-4o-mini', { customer: 'alex@example.com' }),
+ *   prompt: 'What is love?',
+ * });
+ *
+ * // 2. Works with all Vercel AI SDK primitives (streamText, generateObject, streamObject):
+ * const result = streamText({
+ *   model: vibezcheck('gpt-4o', {
+ *     customer: 'alex@example.com',
+ *     pricing: { margin: 1.5 }, // 50% profit margin
+ *   }),
+ *   messages,
+ * });
+ * ```
+ */
+declare function createVibezModel(modelOrId: any, options?: VibezCheckModelOptions): any;
+/**
+ * Creates a scoped session for unified multi-call and tool tracking.
+ */
+declare function createVibezSession(sessionOptions?: VibezSessionOptions): VibezSession;
+declare const vibezcheck: typeof createVibezModel & {
+    session: typeof createVibezSession;
+};
+
+export { type VibezCheckModelOptions, type VibezSession, type VibezSessionOptions, type WithBillingOptions, createVibezModel, createVibezSession, meteredModel, vibezcheck, withBilling };

package/dist/ai-sdk/index.d.ts

@@ -1,12 +1,22 @@
-import { C as CustomerParam, U as UsageEvent } from '../types-CSrSmsd1.js';
-import { V as VibezMeter } from '../client-txrE0D_D.js';
+import { c as CircuitBreakerOptions, C as CustomerParam, B as BillingConfig, P as PricingConfig, d as InlineRateConfig, U as UsageEvent } from '../types-Zbzxg-Ka.js';
+import { V as VibezMeter } from '../client-kJN_Znan.js';
 import 'stripe';
 
-interface WithBillingOptions {
+interface WithBillingOptions extends CircuitBreakerOptions {
     /** Customer email, user ID, or Stripe customer ID */
     customer?: CustomerParam;
     /** Direct Stripe customer ID */
     customerId?: string;
+    /** Billing mode configuration (postpaid vs prepaid) */
+    billing?: BillingConfig;
+    /** Profit margin & minimum charge configuration */
+    pricing?: PricingConfig;
+    /** 1-line inline pricing rate card */
+    rate?: InlineRateConfig;
+    /** Whether to capture tokens if the client aborts or closes tab mid-stream (default: true) */
+    captureOnAbort?: boolean;
+    /** Execution runtime environment (default: 'auto') */
+    runtime?: 'auto' | 'serverless' | 'edge' | 'node';
     /** Stripe API Key override (uses STRIPE_SECRET_KEY env by default) */
     stripeApiKey?: string;
     /** Existing VibezMeter instance (optional) */
@@ -19,16 +29,75 @@ interface WithBillingOptions {
     metadata?: Record<string, string | number | boolean>;
 }
 /**
- * Wraps any Vercel AI SDK LanguageModel (v2 or v3) with automated Stripe billing and token metering.
+ * Wraps any Vercel AI SDK LanguageModel (v2 or v3) with automated Stripe billing, token metering, and agent circuit breakers.
  *
- * @param model - The Vercel AI SDK language model instance (e.g. openai('gpt-5.6-sol'), anthropic('claude-3-7-sonnet'))
- * @param options - Billing & customer configuration
- * @returns Decorated LanguageModel that automatically meters tokens and sends Stripe meter events
+ * Sane Defaults Built-In:
+ * - $0.50 safety ceiling per call (overridable)
+ * - Automatic in-flight token capture on abort
+ * - Automatic prompt caching discount parsing
+ * - Serverless lifecycle preservation
  */
 declare function withBilling<T extends object>(model: T, options?: WithBillingOptions): T;
 /**
- * Alias for withBilling
+ * Convenient alias for withBilling
  */
 declare const meteredModel: typeof withBilling;
 
-export { type WithBillingOptions, meteredModel, withBilling };
+interface VibezCheckModelOptions extends WithBillingOptions {
+    /** OpenAI / AI Gateway API Key override */
+    apiKey?: string;
+    /** AI Gateway / OpenAI Base URL override */
+    baseURL?: string;
+}
+interface VibezSessionOptions {
+    customer?: CustomerParam;
+    stripeApiKey?: string;
+    pricing?: WithBillingOptions['pricing'];
+    billing?: WithBillingOptions['billing'];
+    metadata?: Record<string, string | number | boolean>;
+}
+interface VibezSession {
+    /** Creates a metered model bound to this session customer */
+    model: (modelOrId: any, options?: VibezCheckModelOptions) => any;
+    /** Tracks a non-LLM tool execution cost (e.g. search, scraper, image gen) */
+    trackTool: (name: string, options: {
+        costUSD: number;
+        metadata?: Record<string, any>;
+    }) => Promise<void>;
+    /** Underlying meter instance */
+    meter: VibezMeter;
+}
+/**
+ * Creates or resolves an AI SDK compatible LanguageModel with built-in VibezCheck billing & metering.
+ *
+ * @example
+ * ```typescript
+ * import { generateText, streamText } from 'ai';
+ * import { vibezcheck } from 'vibezcheck';
+ *
+ * // 1. Declarative string model identifier:
+ * const { text } = await generateText({
+ *   model: vibezcheck('openai/gpt-4o-mini', { customer: 'alex@example.com' }),
+ *   prompt: 'What is love?',
+ * });
+ *
+ * // 2. Works with all Vercel AI SDK primitives (streamText, generateObject, streamObject):
+ * const result = streamText({
+ *   model: vibezcheck('gpt-4o', {
+ *     customer: 'alex@example.com',
+ *     pricing: { margin: 1.5 }, // 50% profit margin
+ *   }),
+ *   messages,
+ * });
+ * ```
+ */
+declare function createVibezModel(modelOrId: any, options?: VibezCheckModelOptions): any;
+/**
+ * Creates a scoped session for unified multi-call and tool tracking.
+ */
+declare function createVibezSession(sessionOptions?: VibezSessionOptions): VibezSession;
+declare const vibezcheck: typeof createVibezModel & {
+    session: typeof createVibezSession;
+};
+
+export { type VibezCheckModelOptions, type VibezSession, type VibezSessionOptions, type WithBillingOptions, createVibezModel, createVibezSession, meteredModel, vibezcheck, withBilling };