vibezcheck 0.5.9 → 0.5.10

package/README.md

@@ -1,58 +1,289 @@
 # ✦ VibezCheck
 
-> **Track AI token spend and bill users in real time. Setup in 1 line.**  
-> No database needed. No added latency.
+> **Track AI token spend, protect agent loops, and bill users in real time. Setup in 1 line.**  
+> Zero external dependencies (`dependencies: {}`). 0ms added latency. Works completely offline.
 
 [![npm version](https://img.shields.io/npm/v/vibezcheck.svg?color=cb3837)](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-95%20Passed-brightgreen.svg)]()
+[![Tests](https://img.shields.io/badge/Tests-139%20Passed-brightgreen.svg)]()
 [![Latency](https://img.shields.io/badge/Latency-0ms%20Added-orange.svg)]()
+[![Dependencies](https://img.shields.io/badge/Dependencies-0%20External-success.svg)]()
 
 ---
 
-### The 1-Line Setup
+## ⚡ The 1-Line Setup
 
-**1. On your server:** wrap your model to track spending and set a profit margin
+**1. On your server:** wrap any model to track spending, add profit margin, and set safety fuses:
 ```typescript
-const model = vibezcheck(openai('gpt-4o-mini'), { pricing: { margin: 1.3 } });
+import { openai } from '@ai-sdk/openai';
+import { vibezcheck } from 'vibezcheck';
+
+const model = vibezcheck(openai('gpt-4o-mini'), {
+  customer: 'usr_123',
+  pricing: { margin: 1.3 }, // +30% profit margin
+  maxCostPerCallUSD: 0.50,  // Auto-stops runaway calls at $0.50
+});
 ```
 
-**2. On your frontend:** drop in the component to see spendings in real time
+**2. On your frontend:** drop in the HUD component to display real-time usage:
 ```tsx
+import { VibezCheck } from 'vibezcheck/ui';
+
 <VibezCheck messages={messages} />
 ```
 
-That’s it. You get real-time token tracking, live dollar costs, runaway loop protection, and a sleek spending HUD.
+---
+
+## 📦 Features & Simplest Usage Examples
+
+### 1. 1-Line Model Metering (Vercel AI SDK)
+Wrap existing provider models or use declarative string model identifiers with 0ms added latency:
+```typescript
+import { generateText, streamText } from 'ai';
+import { openai } from '@ai-sdk/openai';
+import { vibezcheck } from 'vibezcheck';
+
+// Option A: Wrap an existing provider instance
+const result = streamText({
+  model: vibezcheck(openai('gpt-4o-mini')),
+  prompt: 'Summarize quantum computing in 3 sentences.',
+});
+
+// Option B: Declarative string model identifier
+const { text } = await generateText({
+  model: vibezcheck('openai/gpt-4o-mini'),
+  prompt: 'Explain general relativity.',
+});
+```
+
+---
+
+### 2. Customer Identification & Session Metadata
+Attach user IDs, agent threads, and custom billing tags without extra database lookups:
+```typescript
+const model = vibezcheck(openai('gpt-4o-mini'), {
+  customer: 'user_alex@example.com',  // User ID, email, or Stripe Customer ID
+  threadId: 'agent_thread_4920',      // Conversation or workflow thread ID
+  metadata: { plan: 'pro', team: 'ai-ops' },
+});
+```
+
+---
+
+### 3. Monetization & Profit Margins (Markups)
+Turn wholesale LLM expenses into profitable revenue with automatic markups:
+```typescript
+const model = vibezcheck(openai('gpt-4o-mini'), {
+  pricing: {
+    margin: 1.25, // 25% profit margin applied to billed cost
+  },
+});
+```
+
+---
+
+### 4. Circuit Breakers (Runaway Loop & Cost Protection)
+Prevent infinite agent loops and accidental multi-hundred-dollar API bills with pre-flight and in-flight circuit breakers:
+```typescript
+const model = vibezcheck(openai('gpt-4o-mini'), {
+  maxCostPerCallUSD: 0.25, // Auto-terminates if call exceeds $0.25
+  maxTokensPerCall: 4000,  // Auto-terminates if prompt + completion exceeds 4,000 tokens
+});
+```
+
+---
+
+### 5. Floating React Spending HUD (`<VibezCheck />`)
+A zero-prop floating financial HUD and expandable card that displays real-time tokens and costs directly from your `useChat()` messages array:
+```tsx
+'use client';
+
+import { useChat } from '@ai-sdk/react';
+import { VibezCheck } from 'vibezcheck/ui'; // or 'vibezcheck/react'
+
+export default function ChatView() {
+  const { messages } = useChat();
+
+  return (
+    <div>
+      {/* Your chat UI */}
+      <VibezCheck messages={messages} />
+    </div>
+  );
+}
+```
+* **⇅ Unit Swap**: Click to toggle between **Dollar Cost** (`$0.0028`) and **Tokens** (`1,420 tok`).
+* **Multi-Model Breakdown**: Automatically displays per-model spend splits when conversations route across multiple models.
+* **Customer Privacy by Default**: Wholesale developer costs and margin formulas remain private unless explicitly enabled.
+
+---
+
+### 6. Per-Message Turn Micro-Receipt (`<VibezReceipt />`)
+Display an elegant micro-badge showing token count, cost, model, and latency below each assistant message:
+```tsx
+import { VibezReceipt } from 'vibezcheck/ui';
+
+// Inside your assistant message bubble
+{message.role === 'assistant' && (
+  <div className="flex justify-end mt-2">
+    <VibezReceipt message={message} />
+  </div>
+)}
+// Renders: ✦ $0.0001 · 31 tok · gpt-4o-mini
+```
+
+---
+
+### 7. Supabase Database Sink
+Persist usage records directly into your Supabase database in the background without slowing down the inference stream:
+```typescript
+import { createClient } from '@supabase/supabase-js';
+import { openai } from '@ai-sdk/openai';
+import { vibezcheck } from 'vibezcheck';
+
+const supabase = createClient(process.env.SUPABASE_URL!, process.env.SUPABASE_KEY!);
+
+const model = vibezcheck(openai('gpt-4o-mini'), {
+  customer: 'usr_alex',
+  database: vibezcheck.supabase(supabase), // Inserts to default 'vibez_usage' table
+});
+```
+
+---
+
+### 8. Extensible DIY Database Adapter (Drizzle, Kysely, MongoDB, ClickHouse)
+Plug in any custom database, ORM, or logging service with a simple 1-line callback:
+```typescript
+import { openai } from '@ai-sdk/openai';
+import { vibezcheck } from 'vibezcheck';
+
+const model = vibezcheck(openai('gpt-4o-mini'), {
+  customer: 'usr_alex',
+  database: vibezcheck.database(async (event) => {
+    // Custom sink: Drizzle, Kysely, Mongo, Prisma, or custom webhook
+    await db.insert(usageEvents).values({
+      customerId: event.customerId,
+      model: event.model,
+      tokens: event.usage.totalTokens,
+      costUSD: event.cost.totalUSD,
+    });
+  }),
+});
+```
+
+---
+
+### 9. Metronome Usage-Based Billing Ingestion
+Directly stream usage records to Metronome's `/v1/ingest` API using native zero-dependency HTTP requests:
+```typescript
+import { openai } from '@ai-sdk/openai';
+import { vibezcheck } from 'vibezcheck';
+
+const model = vibezcheck(openai('gpt-4o-mini'), {
+  customer: 'cust_metronome_456',
+  database: vibezcheck.metronome({
+    apiKey: process.env.METRONOME_API_KEY!,
+  }),
+});
+```
+
+---
+
+### 10. Offline Pricing Engine & Dynamic Rate Sync
+Compute token costs synchronously in 0ms using bundled offline catalogs (700+ models) or optionally sync dynamic upstream rates:
+```typescript
+import { vibezcheck } from 'vibezcheck';
+
+// Synchronous 0ms offline calculation (works without internet)
+const rates = vibezcheck.getModelPricing('gpt-4o-mini');
+// { inputPer1M: 0.15, outputPer1M: 0.60 }
+
+const cost = vibezcheck.calculateCost('gpt-4o-mini', {
+  promptTokens: 1000,
+  completionTokens: 500,
+});
+console.log(cost.totalUSD); // $0.00045
+
+// Optional: refresh rates dynamically in the background
+await vibezcheck.syncPricing();       // Sync Stripe Metronome rates
+await vibezcheck.syncVercelGateway();  // Sync Vercel AI Gateway 260+ models
+```
 
 ---
 
-## What VibezCheck does for you
+### 11. Autonomous Agent Governance & Tool Ceilings
+Enforce a hard budget ceiling over multi-step agent loops and bill for tool invocations:
+```typescript
+import { vibezcheck } from 'vibezcheck';
 
-When you build an AI app, chatbot, or agent:
+const session = vibezcheck.session({
+  customer: 'usr_agent_runner',
+  sessionBudgetUSD: 1.00, // Hard ceiling for entire multi-turn workflow
+});
 
-* **👀 See spending in real time**: You and your users can see the exact cost (e.g. `$0.0014`) and token count for every turn as it streams in.
-* **🛡️ Never get a surprise $500 bill**: A built-in `$0.50` circuit breaker stops runaway prompts or infinite agent loops automatically before they drain your credit card.
-* **💰 Turn costs into profit**: Add `pricing: { margin: 1.3 }` to mark up wholesale API prices by 30%. You make money on every message without writing custom billing code.
-* **🤖 Works with multiple models**: If a conversation uses GPT-4o-mini, Claude 3.5, or Gemini, VibezCheck automatically breaks down the spending per model.
-* **🆓 Zero database required**: Test locally on `localhost:3000` with zero database tables and zero Stripe keys. It runs straight in memory.
-* **⚡ 0ms added latency**: Streaming is direct and transparent. Spending telemetry attaches cleanly at the very end of the stream without delaying first-token response time.
-* **🧹 Clean context window**: Telemetry stays out of your prompts. When messages get sent back to the model on the next turn, telemetry is automatically stripped so you never waste tokens.
+// Bill for tool executions
+const tools = session.tools(myTools, {
+  web_search: { costUSD: 0.01 },
+  code_interpreter: { costUSD: 0.05 },
+});
+```
 
 ---
 
-## 🚀 End-to-End Chatbot Example (Next.js App Router)
+### 12. Serverless Lifecycle Spooling & Manual Flush
+VibezCheck automatically hooks into `globalThis.after()` on Next.js / Vercel and `globalThis.waitUntil()` on Cloudflare Workers so logging never delays stream delivery. You can also explicitly flush before process termination:
+```typescript
+import { vibezcheck } from 'vibezcheck';
+
+// Guarantees all queued usage telemetry is written before worker teardown
+await vibezcheck.flush();
+```
+
+---
 
-Here is a complete, copy-paste ready AI chatbot with live per-message spending receipts and the floating financial HUD:
+### 13. Native Non-AI-SDK Streams (OpenAI, Anthropic, Gemini)
+Meter raw SDK streams outside the Vercel AI SDK with 0ms added latency:
+```typescript
+import OpenAI from 'openai';
+import { vibezcheck } from 'vibezcheck';
 
-### 1. Install Dependencies
+const openai = new OpenAI();
+const client = vibezcheck.create();
+
+const stream = await openai.chat.completions.create({
+  model: 'gpt-4o-mini',
+  messages: [{ role: 'user', content: 'Hello!' }],
+  stream: true,
+  stream_options: { include_usage: true },
+});
+
+// Meter stream in real time
+const meteredStream = client.wrapStream(stream, {
+  model: 'gpt-4o-mini',
+  onUsage: (event) => {
+    console.log(`Billed: $${event.cost.totalUSD} for ${event.usage.totalTokens} tokens`);
+  },
+});
+```
 
+---
+
+### 14. CLI Diagnostics & Starter Scaffolding
+Inspect your codebase for unmetered LLM endpoints or scaffold complete starter templates:
 ```bash
-npm install vibezcheck ai @ai-sdk/openai @ai-sdk/react stripe
+# Scan project routes for unmetered AI SDK calls
+npx vibezcheck audit
+
+# Scaffold starter projects (Next.js App Router, minimal scripts, etc.)
+npx vibezcheck examples
 ```
 
-### 2. Server Route (`app/api/chat/route.ts`)
+---
+
+## 🚀 Complete Next.js App Router Example
 
+### Server Route (`app/api/chat/route.ts`)
 ```typescript
 import { convertToModelMessages, streamText, UIMessage } from 'ai';
 import { openai } from '@ai-sdk/openai';
@@ -64,23 +295,20 @@ export async function POST(req: Request) {
   const { messages }: { messages: UIMessage[] } = await req.json();
 
   const result = streamText({
-    // ✦ 1 Line: track costs, add 30% profit margin, and set $0.50 runaway safety fuse
     model: vibezcheck(openai('gpt-4o-mini'), {
-      customer: 'user_alex@example.com', // User email or Stripe customer ID
-      pricing: { margin: 1.3 },         // +30% profit margin
-      maxCostPerCallUSD: 0.50,          // Auto-stops if call exceeds $0.50
+      customer: 'user_alex@example.com',
+      pricing: { margin: 1.3 }, // +30% margin
+      maxCostPerCallUSD: 0.50,  // Circuit breaker
     }),
-    instructions: 'You are a helpful AI assistant.',
+    instructions: 'You are a helpful assistant.',
     messages: await convertToModelMessages(messages),
   });
 
-  // ✦ Transmits stream with verified spending telemetry attached
   return vibezcheck.toResponse(result);
 }
 ```
 
-### 3. Frontend Client (`app/page.tsx`)
-
+### Frontend Client (`app/page.tsx`)
 ```tsx
 'use client';
 
@@ -92,147 +320,42 @@ import { VibezReceipt, VibezCheck } from 'vibezcheck/ui';
 export default function ChatPage() {
   const [input, setInput] = useState('');
   const { messages, sendMessage, status } = useChat({
-    transport: new DefaultChatTransport({
-      api: '/api/chat',
-    }),
+    transport: new DefaultChatTransport({ api: '/api/chat' }),
   });
 
   return (
     <div className="flex flex-col w-full max-w-lg py-20 mx-auto px-4 min-h-screen">
-      {/* Messages Stream */}
       <div className="flex-1 space-y-4 mb-28">
         {messages.map((message) => (
-          <div
-            key={message.id}
-            className={`p-4 rounded-2xl border ${
-              message.role === 'user'
-                ? 'bg-zinc-100 dark:bg-zinc-800 border-zinc-200 dark:border-zinc-700 ml-10'
-                : 'bg-white dark:bg-zinc-900 border-zinc-200 dark:border-zinc-800 mr-10 shadow-sm'
-            }`}
-          >
-            <div className="text-xs font-semibold uppercase tracking-wider text-zinc-400 mb-1.5">
-              {message.role === 'user' ? 'You' : 'Assistant'}
-            </div>
-
-            {/* Message Text */}
-            <div className="text-sm whitespace-pre-wrap leading-relaxed">
-              {message.parts
-                ? message.parts.map((part, index) => {
-                    switch (part.type) {
-                      case 'text':
-                        return <span key={index}>{part.text}</span>;
-                      default:
-                        return null;
-                    }
-                  })
-                : message.content}
-            </div>
-
-            {/* ✦ 1 Line: Micro-Receipt showing tokens, micro-cost, model, and latency */}
+          <div key={message.id} className="p-4 rounded-xl border">
+            <div>{message.content}</div>
             {message.role === 'assistant' && (
-              <div className="mt-3 flex justify-end">
+              <div className="mt-2 flex justify-end">
                 <VibezReceipt message={message} />
               </div>
             )}
           </div>
         ))}
-
-        {status === 'streaming' && (
-          <div className="text-xs text-zinc-400 italic">Assistant is typing...</div>
-        )}
       </div>
 
-      {/* Input Form */}
-      <form
-        onSubmit={(e) => {
-          e.preventDefault();
-          if (!input.trim()) return;
-          sendMessage({ text: input });
-          setInput('');
-        }}
-        className="fixed bottom-0 left-0 right-0 p-4 bg-white/80 dark:bg-zinc-950/80 backdrop-blur-md border-t border-zinc-200 dark:border-zinc-800"
-      >
-        <div className="max-w-lg mx-auto flex gap-2">
-          <input
-            className="flex-1 p-3 text-sm rounded-xl border border-zinc-300 dark:border-zinc-700 bg-white dark:bg-zinc-900 shadow-sm focus:outline-none focus:ring-2 focus:ring-zinc-900 dark:focus:ring-zinc-100"
-            value={input}
-            placeholder="Type your prompt..."
-            onChange={(e) => setInput(e.target.value)}
-          />
-          <button
-            type="submit"
-            disabled={status === 'streaming' || !input.trim()}
-            className="px-5 py-3 bg-zinc-900 dark:bg-zinc-100 text-white dark:text-zinc-900 text-sm font-semibold rounded-xl hover:opacity-90 disabled:opacity-50 transition"
-          >
-            Send
-          </button>
-        </div>
+      <form onSubmit={(e) => { e.preventDefault(); sendMessage({ text: input }); setInput(''); }}>
+        <input value={input} onChange={(e) => setInput(e.target.value)} placeholder="Type prompt..." />
       </form>
 
-      {/* ✦ 1 Line: Floating HUD showing real-time spending and tokens */}
       <VibezCheck messages={messages} />
     </div>
   );
 }
 ```
 
-### 4. Environment Variables (`.env.local`)
-
-```env
-OPENAI_API_KEY=sk-...
-```
-
 ---
 
-## The UI Components (Zero Props Needed)
-
-Import from `vibezcheck/ui` or `vibezcheck/react`:
-
-### 1. `<VibezCheck messages={messages} />`
-
-A floating financial HUD and expandable card:
-* **⇅ Unit Swap**: Click the `⇅` icon to switch between **Dollar Cost** (`$0.0028`) and **Tokens** (`1,420 tok`).
-* **Session vs Turn**: Switch between `[Session]` (total conversation spend) and `[Latest Turn]` (last reply).
-* **Multi-Model Breakdown**: If you use multiple models in one chat, it shows the exact split for each model.
-* **Customer Privacy by Default**: End-users only see their billed cost. Your wholesale costs and profit margins are hidden by default.
-
-```tsx
-<VibezCheck
-  messages={messages}
-  remainingBalanceUSD={10.00}
-  onTopUp={(amount) => console.log('User wants to top up credits:', amount)}
-/>
-```
-
-### 2. `<VibezReceipt message={message} />`
-
-A small, elegant badge under each assistant message:
-```tsx
-<VibezReceipt message={message} />
-// Renders: ✦ $0.0001 · 31 tok · gpt-4o-mini
-```
-
----
-
-## Multi-Model Sessions (Automatic Breakdown)
-
-If your app routes between different models (e.g. `gpt-4o-mini` for quick chat and `claude-3-5-sonnet` for coding):
-
-VibezCheck automatically detects every model used and lists them in the HUD:
-* `gpt-4o-mini (1 turn)`: 31 tok · $0.0001
-* `claude-3-5-sonnet (1 turn)`: 420 tok · $0.0068
-
-Click any model to see its specific spending.
-
----
-
-## Need Stripe Billing? (Optional)
-
-When you want to charge real money, VibezCheck has built-in Stripe helpers:
+## 🛡️ Core Guarantees & Philosophy
 
-* **Prepaid Credits**: Let users buy credit balance with Stripe Checkout (`BillingHelper.createTopUpSession`).
-* **Customer API Keys**: Issue `vz_live_...` keys saved in Stripe customer metadata (`ApiKeyAuth`).
-* **Agent Session Ceilings**: Limit a multi-step agent to a hard $1.00 budget with `AgentSession`.
+* **Zero Added Latency (0ms)**: Calculations happen in-memory synchronously. Telemetry and database writes occur asynchronously via non-blocking lifecycles.
+* **Pure Zero Runtime Dependencies (`dependencies: {}`)**: Completely self-contained engine. Peer dependencies (`ai`, `@ai-sdk/provider`, `openai`, `react`) are purely optional.
+* **Airbag Failure Isolation**: Database or remote sync outages will never crash user-facing AI chat streams.
+* **Offline-First Resilience**: All rate calculations work immediately with bundled catalogs even with zero network access.
 
 ---
 

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

@@ -1,8 +1,8 @@
-import { W as WithBillingOptions } from '../with-billing-BEqiJtCR.mjs';
-export { m as meteredModel, w as withBilling } from '../with-billing-BEqiJtCR.mjs';
-import { C as CustomerParam } from '../types-Btf2OhIr.mjs';
-import { V as VibezMeter } from '../client-BzwEHQlC.mjs';
-import 'stripe';
+import { W as WithBillingOptions } from '../with-billing-DhHGWCAp.mjs';
+export { m as meteredModel, w as withBilling } from '../with-billing-DhHGWCAp.mjs';
+import { A as AgentSession, a as AgentSessionOptions, c as createAgentSession } from '../session-D9fdP255.mjs';
+import { C as CustomerParam } from '../types-DHlsaLvI.mjs';
+import '../client-ttJwYM7x.mjs';
 
 /**
  * ✦ VibezCheck Universal Telemetry Response Stream Injector
@@ -49,24 +49,8 @@ interface VibezCheckModelOptions extends WithBillingOptions {
     /** AI Gateway / Provider 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;
-}
+type VibezSessionOptions = AgentSessionOptions;
+type VibezSession = AgentSession;
 /**
  * Creates or resolves an AI SDK compatible LanguageModel with built-in VibezCheck billing & metering.
  *
@@ -103,12 +87,108 @@ interface VibezSession {
  */
 declare function createVibezModel(modelOrId: any, options?: VibezCheckModelOptions): any;
 /**
- * Creates a scoped session for unified multi-call and tool tracking.
+ * Creates a scoped agent session for unified multi-call and tool tracking.
+ * Alias for createAgentSession from vibezcheck/billing.
  */
-declare function createVibezSession(sessionOptions?: VibezSessionOptions): VibezSession;
+declare const createVibezSession: typeof createAgentSession;
 declare const vibezcheck: typeof createVibezModel & {
     session: typeof createVibezSession;
     toResponse: typeof toResponse;
 };
 
-export { type ToResponseOptions, type VibezCheckModelOptions, type VibezSession, type VibezSessionOptions, WithBillingOptions, createVibezModel, createVibezSession, toResponse, vibezcheck };
+/**
+ * ✦ VibezCheck Native AI SDK v7 DataUIPart Stream Helper
+ *
+ * Automatically injects native `{ type: 'data-vibezcheck', data }` parts into
+ * AI SDK SSE streams, UI message streams, and Data Stream protocol pipes.
+ *
+ * Seamlessly hydrates client-side `useVibez(messages)` with real-time verified:
+ * - Cost breakdown (costUSD, wholesaleUSD, profitUSD)
+ * - Token metrics (prompt, completion, reasoning, cached)
+ * - Model & Provider metadata
+ * - Tool usage & itemized costs
+ */
+
+/**
+ * Normalized telemetry payload transmitted inside `{ type: 'data-vibezcheck', data: ... }`
+ */
+interface VibezDataStreamPayload {
+    model: string;
+    provider?: string;
+    costUSD: number;
+    wholesaleUSD: number;
+    profitUSD: number;
+    tokens: number;
+    promptTokens: number;
+    completionTokens: number;
+    reasoningTokens?: number;
+    cachedTokens?: number;
+    toolCalls?: Array<{
+        name: string;
+        calls: number;
+        costUSD: number;
+        latencyMs?: number;
+    }>;
+    customerId?: string;
+    timestamp?: string;
+    metadata?: Record<string, any>;
+    [key: string]: any;
+}
+interface ToVibezDataStreamOptions {
+    /** Explicit telemetry payload or overrides */
+    telemetry?: Partial<VibezDataStreamPayload>;
+    /** Customer param for billing attribution */
+    customer?: CustomerParam;
+    /** Model override if not auto-detected */
+    model?: string;
+    /** Profit margin multiplier if recalculating (e.g. 1.30 for 30%) */
+    margin?: number;
+    /** Callback fired when telemetry is written to stream */
+    onTelemetry?: (telemetry: VibezDataStreamPayload) => void | Promise<void>;
+    /** Custom extra stream parts to emit alongside data-vibezcheck */
+    extraParts?: any[];
+}
+/**
+ * Augmented ReadableStream with convenient 1-line `.toResponse()` helper
+ */
+interface VibezDataStream extends ReadableStream<any> {
+    toResponse(init?: ResponseInit & {
+        headers?: HeadersInit;
+    }): Response;
+}
+/**
+ * Normalizes any raw telemetry or usage event into a canonical VibezDataStreamPayload
+ */
+declare function normalizeTelemetryPayload(raw?: any, options?: ToVibezDataStreamOptions): VibezDataStreamPayload;
+/**
+ * Transforms an AI SDK stream (or StreamTextResult) into a VibezDataStream
+ * that writes native `{ type: 'data-vibezcheck', data }` parts directly into the SSE stream.
+ *
+ * @example
+ * ```typescript
+ * import { streamText } from 'ai';
+ * import { openai } from '@ai-sdk/openai';
+ * import { vibezcheck, toVibezDataStream } from 'vibezcheck';
+ *
+ * export async function POST(req: Request) {
+ *   const { messages } = await req.json();
+ *   const result = streamText({
+ *     model: vibezcheck(openai('gpt-4o')),
+ *     messages,
+ *   });
+ *
+ *   // ✦ 1-Line Data Stream with Native Telemetry Part
+ *   return toVibezDataStream(result).toResponse();
+ * }
+ * ```
+ */
+declare function toVibezDataStream(source: any, options?: ToVibezDataStreamOptions): VibezDataStream;
+/**
+ * Transforms an AI SDK stream into an HTTP Response with native `data-vibezcheck` telemetry parts.
+ */
+declare function toVibezDataStreamResponse(source: any, options?: ToVibezDataStreamOptions & {
+    init?: ResponseInit;
+    headers?: HeadersInit;
+}): Response;
+
+export { type ToResponseOptions, type ToVibezDataStreamOptions, type VibezCheckModelOptions, type VibezDataStream, type VibezDataStreamPayload, type VibezSession, type VibezSessionOptions, WithBillingOptions, createVibezModel, createVibezSession, normalizeTelemetryPayload, toResponse, toVibezDataStream, toVibezDataStreamResponse, vibezcheck };