vibezcheck 0.2.0 → 0.3.0

package/dist/index.mjs

@@ -1,3 +1,10 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
 // src/index.ts
 import Stripe5 from "stripe";
 
@@ -822,6 +829,16 @@ function createMeter(options = {}) {
   return new VibezMeter(options);
 }
 
+// src/types.ts
+var VibezCircuitBreakerError = class extends Error {
+  event;
+  constructor(event) {
+    super(event.message);
+    this.name = "VibezCircuitBreakerError";
+    this.event = event;
+  }
+};
+
 // src/ai-sdk/with-billing.ts
 function withBilling(model, options = {}) {
   if (!model || typeof model !== "object") {
@@ -849,6 +866,38 @@ function withBilling(model, options = {}) {
       cachedTokens: cachedTokens > 0 ? cachedTokens : void 0
     };
     const cost = calculateUsageCost(modelId, usage);
+    if (options.maxCostPerCallUSD && cost.totalUSD > options.maxCostPerCallUSD) {
+      const budgetEvent = {
+        reason: "cost_per_call_exceeded",
+        limit: options.maxCostPerCallUSD,
+        current: cost.totalUSD,
+        model: modelId,
+        customerId,
+        message: `[vibezcheck] Circuit Breaker tripped: Call cost ($${cost.totalUSD.toFixed(4)}) exceeded maxCostPerCallUSD threshold ($${options.maxCostPerCallUSD.toFixed(4)}).`
+      };
+      if (options.onBudgetExceeded) {
+        options.onBudgetExceeded(budgetEvent);
+      }
+      if (options.throwOnBudgetExceeded) {
+        throw new VibezCircuitBreakerError(budgetEvent);
+      }
+    }
+    if (options.maxTokensPerCall && usage.totalTokens > options.maxTokensPerCall) {
+      const budgetEvent = {
+        reason: "max_tokens_exceeded",
+        limit: options.maxTokensPerCall,
+        current: usage.totalTokens,
+        model: modelId,
+        customerId,
+        message: `[vibezcheck] Circuit Breaker tripped: Token count (${usage.totalTokens}) exceeded maxTokensPerCall limit (${options.maxTokensPerCall}).`
+      };
+      if (options.onBudgetExceeded) {
+        options.onBudgetExceeded(budgetEvent);
+      }
+      if (options.throwOnBudgetExceeded) {
+        throw new VibezCircuitBreakerError(budgetEvent);
+      }
+    }
     const event = {
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
       model: modelId,
@@ -872,18 +921,9 @@ function withBilling(model, options = {}) {
       options.onUsage(event);
     }
   };
-  return new Proxy(model, {
+  const handler = {
     get(target, prop, receiver) {
       const originalValue = Reflect.get(target, prop, receiver);
-      if (prop === "doGenerate" && typeof originalValue === "function") {
-        return async function(...args) {
-          const result = await originalValue.apply(target, args);
-          if (result && result.usage) {
-            handleUsage(result.usage);
-          }
-          return result;
-        };
-      }
       if (prop === "doStream" && typeof originalValue === "function") {
         return async function(...args) {
           const result = await originalValue.apply(target, args);
@@ -891,61 +931,86 @@ function withBilling(model, options = {}) {
             return result;
           }
           const originalStream = result.stream;
-          if (typeof originalStream.getReader === "function") {
-            const reader = originalStream.getReader();
-            const transformedStream = new ReadableStream({
-              async start(controller) {
-                try {
-                  while (true) {
-                    const { done, value } = await reader.read();
-                    if (done) {
-                      controller.close();
-                      break;
-                    }
-                    if (value && typeof value === "object") {
-                      if (value.type === "finish" && value.usage) {
-                        handleUsage(value.usage);
-                      }
-                    }
-                    controller.enqueue(value);
-                  }
-                } catch (err) {
-                  controller.error(err);
-                }
-              }
-            });
-            return {
-              ...result,
-              stream: transformedStream
-            };
-          }
-          if (Symbol.asyncIterator in originalStream) {
-            const wrappedAsyncIterable = {
-              async *[Symbol.asyncIterator]() {
-                for await (const chunk of originalStream) {
-                  if (chunk && typeof chunk === "object") {
-                    if (chunk.type === "finish" && chunk.usage) {
-                      handleUsage(chunk.usage);
-                    }
-                  }
-                  yield chunk;
-                }
+          const transformStream = new TransformStream({
+            transform(chunk, controller) {
+              controller.enqueue(chunk);
+              if (chunk.type === "finish" && chunk.usage) {
+                handleUsage(chunk.usage);
               }
-            };
-            return {
-              ...result,
-              stream: wrappedAsyncIterable
-            };
+            }
+          });
+          return {
+            ...result,
+            stream: originalStream.pipeThrough(transformStream)
+          };
+        };
+      }
+      if (prop === "doGenerate" && typeof originalValue === "function") {
+        return async function(...args) {
+          const result = await originalValue.apply(target, args);
+          if (result && result.usage) {
+            handleUsage(result.usage);
           }
           return result;
         };
       }
       return originalValue;
     }
-  });
+  };
+  return new Proxy(model, handler);
 }
 var meteredModel = withBilling;
 
+// src/ai-sdk/declarative.ts
+function createVibezModel(modelOrId, options = {}) {
+  if (typeof modelOrId === "object" && modelOrId !== null) {
+    return withBilling(modelOrId, options);
+  }
+  if (typeof modelOrId === "string") {
+    const rawId = modelOrId;
+    let providerName = "openai";
+    let cleanModelId = rawId;
+    if (rawId.includes("/")) {
+      const parts = rawId.split("/");
+      providerName = parts[0].toLowerCase();
+      cleanModelId = parts.slice(1).join("/");
+    }
+    const apiKey = options.apiKey || process.env.AI_GATEWAY_API_KEY || process.env.OPENAI_API_KEY || process.env.ANTHROPIC_API_KEY || process.env.GOOGLE_GENERATIVE_AI_API_KEY;
+    const baseURL = options.baseURL || process.env.AI_GATEWAY_BASE_URL || (providerName === "openai" ? "https://api.openai.com/v1" : void 0);
+    let baseModelInstance = null;
+    try {
+      if (providerName === "openai" || providerName === "gateway" || !providerName) {
+        const { createOpenAI } = __require("@ai-sdk/openai");
+        const openaiProvider = createOpenAI({ apiKey, baseURL });
+        baseModelInstance = openaiProvider(cleanModelId);
+      } else if (providerName === "anthropic") {
+        const { createAnthropic } = __require("@ai-sdk/anthropic");
+        const anthropicProvider = createAnthropic({ apiKey, baseURL });
+        baseModelInstance = anthropicProvider(cleanModelId);
+      } else if (providerName === "google") {
+        const { createGoogleGenerativeAI } = __require("@ai-sdk/google");
+        const googleProvider = createGoogleGenerativeAI({ apiKey, baseURL });
+        baseModelInstance = googleProvider(cleanModelId);
+      }
+    } catch {
+      baseModelInstance = {
+        specificationVersion: "v2",
+        provider: providerName,
+        modelId: cleanModelId
+      };
+    }
+    if (!baseModelInstance) {
+      baseModelInstance = {
+        specificationVersion: "v2",
+        provider: providerName,
+        modelId: cleanModelId
+      };
+    }
+    return withBilling(baseModelInstance, options);
+  }
+  return modelOrId;
+}
+
 // src/customers/manager.ts
 import Stripe2 from "stripe";
 
@@ -1284,43 +1349,12 @@ var VibezCheckClient = class {
     });
   }
   /**
-   * 1-Line Universal Stream Responder for API Routes (Next.js, Express, Hono)
+   * Declarative model resolver for Vercel AI SDK
    */
-  async stream(params) {
-    const OpenAI = (await import("openai")).default;
-    const openai = new OpenAI();
-    const responseStream = await openai.chat.completions.create({
-      model: params.model,
-      messages: params.messages,
-      stream: true,
-      stream_options: { include_usage: true },
-      temperature: params.temperature
-    });
-    const meteredStream = this.wrapStream(responseStream, {
-      customer: params.customer,
-      model: params.model
-    });
-    const encoder = new TextEncoder();
-    const readable = new ReadableStream({
-      async start(controller) {
-        try {
-          for await (const chunk of meteredStream) {
-            const text = chunk.choices?.[0]?.delta?.content || "";
-            if (text) {
-              controller.enqueue(encoder.encode(text));
-            }
-          }
-          controller.close();
-        } catch (err) {
-          controller.error(err);
-        }
-      }
-    });
-    return new Response(readable, {
-      headers: {
-        "Content-Type": "text/plain; charset=utf-8",
-        "Transfer-Encoding": "chunked"
-      }
+  model(modelOrId, options) {
+    return createVibezModel(modelOrId, {
+      ...options,
+      meter: this.meter
     });
   }
   /**
@@ -1339,9 +1373,20 @@ var VibezCheckClient = class {
 function createVibezCheck(config = {}) {
   return new VibezCheckClient(config);
 }
-var vibezcheck = createVibezCheck;
-var vibescheck = createVibezCheck;
-var vibez = createVibezCheck();
+function vibezcheck(firstArg, secondArg) {
+  if (typeof firstArg === "string" || firstArg && (firstArg.specificationVersion || firstArg.doGenerate || firstArg.doStream)) {
+    return createVibezModel(firstArg, secondArg);
+  }
+  return new VibezCheckClient(firstArg || {});
+}
+vibezcheck.calculateCost = calculateCost;
+vibezcheck.getModelPricing = getModelPricing;
+vibezcheck.registerModelPricing = registerModelPricing;
+vibezcheck.create = createVibezCheck;
+vibezcheck.withBilling = withBilling;
+vibezcheck.createMeter = createMeter;
+var vibez = new VibezCheckClient();
+var vibescheck = vibezcheck;
 var vibes = vibez;
 export {
   AnthropicStreamAccumulator,
@@ -1352,6 +1397,7 @@ export {
   MODEL_PRICING_TABLE,
   MeterBatcher,
   VibezCheckClient,
+  VibezCircuitBreakerError,
   VibezMeter,
   calculateCost,
   calculateUsageCost,
@@ -1360,6 +1406,7 @@ export {
   createCustomerManager,
   createMeter,
   createVibezCheck,
+  createVibezModel,
   detectAndExtractUsage,
   extractAnthropicResponseUsage,
   extractAuthToken,