vibezcheck 0.5.10 → 0.5.12

package/README.md

@@ -1,167 +1,348 @@
 # ✦ VibezCheck
 
-> **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.
+Know what every AI request costs.  
+The cost layer for AI applications.
 
-[![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-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)]()
+VibezCheck measures AI usage in real dollars — per request, customer, feature, model, or agent session.
+
+```text
+AI request → tokens → provider cost → customer economics
+```
+
+```bash
+npm install vibezcheck
+```
 
 ---
 
-## ⚡ The 1-Line Setup
+## Why VibezCheck?
 
-**1. On your server:** wrap any model to track spending, add profit margin, and set safety fuses:
-```typescript
-import { openai } from '@ai-sdk/openai';
-import { vibezcheck } from 'vibezcheck';
+Tokens are useful for engineers.  
+Dollars are useful for businesses.
 
-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
-});
-```
+AI providers bill you in tokens.
 
-**2. On your frontend:** drop in the HUD component to display real-time usage:
-```tsx
-import { VibezCheck } from 'vibezcheck/ui';
+Your users buy:
+- messages
+- documents
+- agent runs
+- API calls
+- credits
+- subscriptions
 
-<VibezCheck messages={messages} />
+VibezCheck connects the two.
+
+```text
+What your user does
+       ↓
+   AI usage
+       ↓
+ Provider cost
+       ↓
+Customer economics
 ```
 
+Without a metering layer, you know what your users are doing — but not necessarily what each action costs you.
+
 ---
 
-## 📦 Features & Simplest Usage Examples
+## ⚡ Quick Start
+
+### Vercel AI SDK
+
+Wrap an existing model:
 
-### 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 { 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.',
+  model: vibezcheck(openai('gpt-4o-mini'), {
+    customer: 'user_123',
+    maxCostPerCallUSD: 0.50,
+  }),
+  prompt: 'Summarize quantum computing in three sentences.',
 });
 ```
 
+That's it.
+
+VibezCheck can now calculate the request's usage and provider cost while the request runs.
+
+**Example:**
+> `✦ $0.0028 · 1,420 tok · gpt-4o-mini`
+
+- No VibezCheck proxy.
+- No required database.
+- No required cloud account.
+
 ---
 
-### 2. Customer Identification & Session Metadata
-Attach user IDs, agent threads, and custom billing tags without extra database lookups:
+## 💰 Measure
+
+VibezCheck gives your application an economic view of AI usage.
+
+### Request cost
+
 ```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' },
+const cost = vibezcheck.calculateCost('gpt-4o-mini', {
+  promptTokens: 1240,
+  completionTokens: 150,
 });
+console.log(cost.totalUSD);
+// 0.000276
 ```
 
----
+### Customer attribution
 
-### 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
+  customer: 'user_123',
+  threadId: 'thread_456',
+  metadata: {
+    plan: 'pro',
+    feature: 'document-analysis',
   },
 });
 ```
 
+Track usage by:
+- customer
+- organization
+- feature
+- thread
+- model
+- agent session
+
 ---
 
-### 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:
+## 🛡️ Control
+
+AI agents can make multiple calls before a workflow finishes.  
+Put a ceiling on them.
+
+### Per-request limits
+
 ```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
+  maxCostPerCallUSD: 0.25,
+  maxTokensPerCall: 4000,
+});
+```
+
+### Agent session budgets
+
+```typescript
+const session = vibezcheck.session({
+  customer: 'tenant_123',
+  sessionBudgetUSD: 2.00,
 });
 ```
 
+The entire workflow gets a hard spending ceiling.
+
+### Tool costs
+
+```typescript
+const tools = session.tools(agentTools, {
+  web_search: {
+    costUSD: 0.01,
+  },
+  code_interpreter: {
+    costUSD: 0.05,
+  },
+});
+```
+
+Now you can account for:
+
+```text
+LLM usage + Tool usage = Agent cost
+```
+
 ---
 
-### 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';
+## 💳 Monetize
 
-import { useChat } from '@ai-sdk/react';
-import { VibezCheck } from 'vibezcheck/ui'; // or 'vibezcheck/react'
+Your provider cost can become part of your application's pricing model.
 
-export default function ChatView() {
-  const { messages } = useChat();
+```typescript
+const model = vibezcheck(openai('gpt-4o-mini'), {
+  customer: 'user_123',
+  pricing: {
+    markup: 1.3,
+  },
+});
+```
 
-  return (
-    <div>
-      {/* Your chat UI */}
-      <VibezCheck messages={messages} />
-    </div>
-  );
-}
+A 1.3x markup means:
+
+```text
+Provider cost   $1.00
+Customer price  $1.30
+─────────────────────
+Markup            30%
 ```
-* **⇅ 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.
+
+This lets you build products where AI usage can map directly to:
+- credits
+- usage limits
+- customer pricing
+- subscriptions
+- metered billing
 
 ---
 
-### 6. Per-Message Turn Micro-Receipt (`<VibezReceipt />`)
-Display an elegant micro-badge showing token count, cost, model, and latency below each assistant message:
+## 🧾 AI Cost Receipts
+
+Show users the cost of individual AI responses.
+
 ```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>
+  <VibezReceipt message={message} />
 )}
-// Renders: ✦ $0.0001 · 31 tok · gpt-4o-mini
+```
+
+**Example:**
+> `✦ $0.0001 · 31 tok · gpt-4o-mini`
+
+For complete conversations, use the spending HUD:
+
+```tsx
+import { VibezCheck } from 'vibezcheck/ui';
+
+<VibezCheck messages={messages} />
+```
+
+The HUD can show:
+
+```text
+┌─────────────────────────┐
+│ AI Usage                │
+│                         │
+│ $0.0248                 │
+│ 12,420 tokens           │
+│                         │
+│ gpt-4o-mini     $0.0182 │
+│ gpt-4o          $0.0066 │
+└─────────────────────────┘
 ```
 
 ---
 
-### 7. Supabase Database Sink
-Persist usage records directly into your Supabase database in the background without slowing down the inference stream:
+## 🔌 Native Provider Streams
+
+VibezCheck also works outside the Vercel AI SDK.
+
 ```typescript
-import { createClient } from '@supabase/supabase-js';
-import { openai } from '@ai-sdk/openai';
+import OpenAI from 'openai';
 import { vibezcheck } from 'vibezcheck';
 
-const supabase = createClient(process.env.SUPABASE_URL!, process.env.SUPABASE_KEY!);
+const openai = new OpenAI();
+const client = vibezcheck.create();
 
-const model = vibezcheck(openai('gpt-4o-mini'), {
-  customer: 'usr_alex',
-  database: vibezcheck.supabase(supabase), // Inserts to default 'vibez_usage' table
+const stream = await openai.chat.completions.create({
+  model: 'gpt-4o-mini',
+  messages: [
+    {
+      role: 'user',
+      content: 'Hello!',
+    },
+  ],
+  stream: true,
+  stream_options: {
+    include_usage: true,
+  },
+});
+
+const meteredStream = client.wrapStream(stream, {
+  model: 'gpt-4o-mini',
+  customer: 'user_123',
+  onUsage: (event) => {
+    console.log(
+      `Cost: $${event.cost.totalUSD} (${event.usage.totalTokens} tokens)`
+    );
+  },
 });
 ```
 
+Use VibezCheck with native provider streams without routing requests through a VibezCheck gateway.
+
 ---
 
-### 8. Extensible DIY Database Adapter (Drizzle, Kysely, MongoDB, ClickHouse)
-Plug in any custom database, ORM, or logging service with a simple 1-line callback:
+## 💵 Offline Pricing Engine
+
+VibezCheck includes a bundled pricing catalog so known model costs can be calculated locally.
+
 ```typescript
-import { openai } from '@ai-sdk/openai';
-import { vibezcheck } from 'vibezcheck';
+const rates = vibezcheck.getModelPricing('gpt-4o-mini');
+console.log(rates);
+// { inputPer1M: 0.15, outputPer1M: 0.60 }
+```
+
+Calculate costs synchronously:
 
+```typescript
+const cost = vibezcheck.calculateCost('gpt-4o-mini', {
+  promptTokens: 1000,
+  completionTokens: 500,
+});
+console.log(cost.totalUSD);
+// 0.00045
+```
+
+Optional pricing synchronization:
+
+```typescript
+await vibezcheck.syncPricing();
+await vibezcheck.syncVercelGateway();
+```
+
+---
+
+## 📊 700+ Model Pricing Catalog
+
+VibezCheck ships with pricing information for hundreds of models and providers.
+
+| Provider | Examples |
+|---|---|
+| **OpenAI** | GPT-4o, GPT-4o-mini, o1, o3-mini |
+| **Anthropic** | Claude 3.5 Sonnet, Claude 3.5 Haiku, Claude 3 Opus |
+| **Google** | Gemini 2.0 Flash, Gemini 1.5 Pro, Gemini 1.5 Flash |
+| **DeepSeek** | DeepSeek R1, DeepSeek V3 |
+| **Meta / Groq** | Llama 3.3 70B, Llama 3.1 8B |
+| **Mistral** | Mistral Large, Codestral, Pixtral |
+| **Gateways / Cloud** | AWS Bedrock, Azure OpenAI, OpenRouter, Vercel AI Gateway |
+
+Pricing is bundled locally for offline calculations and can optionally be refreshed.
+
+---
+
+## 🗄️ Store Usage Events
+
+VibezCheck does not require a database.  
+When you want persistence, attach a sink.
+
+### Supabase
+
+```typescript
+const model = vibezcheck(openai('gpt-4o-mini'), {
+  customer: 'user_123',
+  database: vibezcheck.supabase(supabase),
+});
+```
+
+### Custom database
+
+Use your existing infrastructure:
+
+```typescript
 const model = vibezcheck(openai('gpt-4o-mini'), {
-  customer: 'usr_alex',
+  customer: 'user_123',
   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,
@@ -172,193 +353,294 @@ const model = vibezcheck(openai('gpt-4o-mini'), {
 });
 ```
 
+Use your own:
+- PostgreSQL
+- Supabase
+- Drizzle
+- Prisma
+- MongoDB
+- ClickHouse
+- webhooks
+- analytics systems
+
 ---
 
-### 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';
+## 💳 Billing Integrations
 
-const model = vibezcheck(openai('gpt-4o-mini'), {
-  customer: 'cust_metronome_456',
-  database: vibezcheck.metronome({
-    apiKey: process.env.METRONOME_API_KEY!,
+Usage events can be connected to billing systems such as Stripe or Metronome.
+
+For example:
+
+```typescript
+const model = vibezcheck('openai/gpt-4o-mini', {
+  customer: 'cus_123',
+  database: vibezcheck.database(async (event) => {
+    // Send event to your billing system
+    await recordBillableUsage({
+      customerId: event.customerId,
+      costUSD: event.cost.totalUSD,
+    });
   }),
 });
 ```
 
+VibezCheck gives you the usage event.  
+You decide how that usage becomes revenue.
+
 ---
 
-### 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:
+## 🧠 AI Agents
+
+Agentic applications need more than token tracking.  
+They need economic boundaries.
+
 ```typescript
-import { vibezcheck } from 'vibezcheck';
+const session = vibezcheck.session({
+  customer: 'enterprise_123',
+  sessionBudgetUSD: 5.00,
+});
 
-// Synchronous 0ms offline calculation (works without internet)
-const rates = vibezcheck.getModelPricing('gpt-4o-mini');
-// { inputPer1M: 0.15, outputPer1M: 0.60 }
+const tools = session.tools(agentTools, {
+  web_search: {
+    costUSD: 0.01,
+  },
+  code_interpreter: {
+    costUSD: 0.05,
+  },
+});
 
-const cost = vibezcheck.calculateCost('gpt-4o-mini', {
-  promptTokens: 1000,
-  completionTokens: 500,
+const result = await runAutonomousWorkflow({
+  model: session.model('gpt-4o'),
+  tools,
 });
-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
+VibezCheck can track:
+
+```text
+Model calls + Tool calls + Multiple turns
+                  ↓
+          Total agent cost
 ```
 
 ---
 
-### 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';
+## 🏗️ Production Characteristics
 
-const session = vibezcheck.session({
-  customer: 'usr_agent_runner',
-  sessionBudgetUSD: 1.00, // Hard ceiling for entire multi-turn workflow
-});
+### Zero runtime dependencies
+`dependencies: {}`  
+The core library does not require an external runtime dependency.  
+Provider SDKs, React, and database clients are optional integrations.
 
-// Bill for tool executions
-const tools = session.tools(myTools, {
-  web_search: { costUSD: 0.01 },
-  code_interpreter: { costUSD: 0.05 },
-});
-```
+### No network proxy
+Model requests continue directly between your application and the provider.  
+VibezCheck runs inside your application.
 
----
+### No prompt storage by default
+VibezCheck does not need to store prompts or model completions to calculate usage and cost.  
+Your application controls what gets persisted through optional database adapters.
 
-### 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';
+### Failure isolation
+Telemetry and database reporting should not become a dependency of the user-facing AI response.  
+VibezCheck supports asynchronous reporting through serverless lifecycle mechanisms such as:
+- Next.js / Vercel `globalThis.after()`
+- Cloudflare Workers `waitUntil()`
 
-// Guarantees all queued usage telemetry is written before worker teardown
-await vibezcheck.flush();
-```
+### Offline capable
+The bundled pricing catalog allows cost calculations without requiring an external network request.
 
 ---
 
-### 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';
+## 🔄 How It Works
+
+```text
+Your Application
+       │
+       ▼
+┌──────────────────┐
+│   AI Provider    │
+│ OpenAI / Claude  │
+│  Gemini / etc.   │
+└────────┬─────────┘
+         │
+         ▼
+┌──────────────────┐
+│   VibezCheck     │
+│                  │
+│     Usage        │
+│     Cost         │
+│  Attribution     │
+│     Limits       │
+└────────┬─────────┘
+         │
+    ┌────┴────┐
+    ▼         ▼
+Application  Async sinks
+ economics   DB / billing / analytics
+```
 
-const openai = new OpenAI();
-const client = vibezcheck.create();
+The important part:  
+Your model traffic stays in your application path.  
+VibezCheck adds the economic layer around it.
 
-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`);
-  },
-});
-```
+## 🧩 Supported Integrations
+
+### AI SDKs
+- Vercel AI SDK
+- OpenAI
+- Anthropic
+- Gemini
+- Native streaming APIs
+
+### Storage
+- Supabase
+- Custom database adapters
+- PostgreSQL
+- Drizzle
+- Prisma
+- MongoDB
+- ClickHouse
+
+### Billing
+- Stripe
+- Metronome
+- Custom billing systems
+
+### UI
+- React
+- `<VibezReceipt />`
+- `<VibezCheck />`
 
 ---
 
-### 14. CLI Diagnostics & Starter Scaffolding
-Inspect your codebase for unmetered LLM endpoints or scaffold complete starter templates:
+## 🔍 CLI
+
+Audit your project for potentially unmetered AI calls:
+
 ```bash
-# Scan project routes for unmetered AI SDK calls
 npx vibezcheck audit
+```
 
-# Scaffold starter projects (Next.js App Router, minimal scripts, etc.)
+Generate starter examples:
+
+```bash
 npx vibezcheck examples
 ```
 
 ---
 
-## 🚀 Complete Next.js App Router Example
+## 🚀 Complete Example
+
+A typical AI chat application can look like this:
 
-### Server Route (`app/api/chat/route.ts`)
 ```typescript
-import { convertToModelMessages, streamText, UIMessage } from 'ai';
+import { streamText } from 'ai';
 import { openai } from '@ai-sdk/openai';
 import { vibezcheck } from 'vibezcheck';
 
-export const maxDuration = 30;
-
 export async function POST(req: Request) {
-  const { messages }: { messages: UIMessage[] } = await req.json();
+  const { messages, userId } = await req.json();
 
   const result = streamText({
     model: vibezcheck(openai('gpt-4o-mini'), {
-      customer: 'user_alex@example.com',
-      pricing: { margin: 1.3 }, // +30% margin
-      maxCostPerCallUSD: 0.50,  // Circuit breaker
+      customer: userId,
+      pricing: {
+        markup: 1.3,
+      },
+      maxCostPerCallUSD: 0.50,
     }),
-    instructions: 'You are a helpful assistant.',
-    messages: await convertToModelMessages(messages),
+    messages,
   });
 
   return vibezcheck.toResponse(result);
 }
 ```
 
-### Frontend Client (`app/page.tsx`)
-```tsx
-'use client';
-
-import { useChat } from '@ai-sdk/react';
-import { DefaultChatTransport } from 'ai';
-import { useState } from 'react';
-import { VibezReceipt, VibezCheck } from 'vibezcheck/ui';
+Your application now has:
+- ✓ Model usage
+- ✓ Dollar cost
+- ✓ Customer attribution
+- ✓ Pricing / markup
+- ✓ Per-request protection
+- ✓ Streaming support
 
-export default function ChatPage() {
-  const [input, setInput] = useState('');
-  const { messages, sendMessage, status } = useChat({
-    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">
-      <div className="flex-1 space-y-4 mb-28">
-        {messages.map((message) => (
-          <div key={message.id} className="p-4 rounded-xl border">
-            <div>{message.content}</div>
-            {message.role === 'assistant' && (
-              <div className="mt-2 flex justify-end">
-                <VibezReceipt message={message} />
-              </div>
-            )}
-          </div>
-        ))}
-      </div>
-
-      <form onSubmit={(e) => { e.preventDefault(); sendMessage({ text: input }); setInput(''); }}>
-        <input value={input} onChange={(e) => setInput(e.target.value)} placeholder="Type prompt..." />
-      </form>
-
-      <VibezCheck messages={messages} />
-    </div>
-  );
-}
+## 🎯 The Economic Layer for AI
+
+AI applications are becoming more autonomous.  
+More messages.  
+More context.  
+More tool calls.  
+More model calls.  
+More cost.
+
+VibezCheck gives your application a way to understand that cost at the point where the AI request happens.
+
+```text
+       MEASURE
+          │
+    ┌─────┴─────┐
+    │           │
+ tokens      dollars
+    │           │
+    └─────┬─────┘
+          │
+       CONTROL
+  budgets / limits
+          │
+      MONETIZE
+  pricing / billing
 ```
 
+**Know what every AI request costs.**
+
+---
+
+## Roadmap
+
+### Current
+- Request-level cost metering
+- 700+ model pricing catalog
+- Streaming support
+- Customer attribution
+- Circuit breakers
+- Agent session budgets
+- Tool cost tracking
+- React usage UI
+- Database sinks
+
+### Next
+- Persistent cost history
+- Per-customer budgets
+- Spend alerts
+- Cost anomaly detection
+- Native billing integrations
+- Unit economics analytics
+
 ---
 
-## 🛡️ Core Guarantees & Philosophy
+## Contributing
+
+Contributions are welcome.
+
+```bash
+pnpm install
+pnpm test
+pnpm typecheck
+```
+
+To update model pricing:  
+`src/pricing/catalog.ts`
 
-* **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.
+Please ensure tests pass and no unnecessary runtime dependencies are introduced.
 
 ---
 
-## 📄 License
+## License
 
-MIT © [VibezCheck](https://vibezcheck.xyz)
+MIT © VibezCheck  
+[Website](https://vibezcheck.xyz/) · [npm](https://www.npmjs.com/package/vibezcheck)  
+Contact: [yt@vibezcheck.app](mailto:yt@vibezcheck.app)