@nordsym/apiclaw 1.5.16 → 1.5.18

package/dist/convex/purchases.js

@@ -1,156 +0,0 @@
-import { v } from "convex/values";
-import { mutation, query } from "./_generated/server";
-// Provider pricing (credits per dollar)
-const CREDITS_PER_DOLLAR = {
-    "46elks": 30, // ~30 SMS per dollar
-    twilio: 25, // ~25 SMS per dollar
-    resend: 1000, // ~1000 emails per dollar
-    brave_search: 200, // ~200 searches per dollar
-    openrouter: 100, // ~100k tokens per dollar
-    elevenlabs: 3333, // ~3333 characters per dollar
-};
-// Calculate credits for a provider purchase
-function calculateCredits(providerId, amountUsd) {
-    const rate = CREDITS_PER_DOLLAR[providerId] || 100;
-    return Math.floor(amountUsd * rate);
-}
-// Purchase API access
-export const purchaseAccess = mutation({
-    args: {
-        agentId: v.string(),
-        providerId: v.string(),
-        amountUsd: v.number(),
-        credentials: v.any(), // Credentials passed from server side
-    },
-    handler: async (ctx, args) => {
-        // Check balance
-        const credits = await ctx.db
-            .query("agentCredits")
-            .withIndex("by_agentId", (q) => q.eq("agentId", args.agentId))
-            .first();
-        if (!credits || credits.balanceUsd < args.amountUsd) {
-            throw new Error(`Insufficient balance: have $${(credits?.balanceUsd || 0).toFixed(2)}, need $${args.amountUsd.toFixed(2)}`);
-        }
-        // Deduct credits
-        await ctx.db.patch(credits._id, {
-            balanceUsd: credits.balanceUsd - args.amountUsd,
-            updatedAt: Date.now(),
-        });
-        // Calculate credits granted
-        const creditsGranted = calculateCredits(args.providerId, args.amountUsd);
-        // Create purchase record
-        const purchaseId = await ctx.db.insert("purchases", {
-            agentId: args.agentId,
-            providerId: args.providerId,
-            amountUsd: args.amountUsd,
-            creditsGranted,
-            status: "active",
-            credentials: args.credentials,
-            createdAt: Date.now(),
-        });
-        // Initialize usage tracking
-        await ctx.db.insert("usage", {
-            purchaseId,
-            providerId: args.providerId,
-            unitsUsed: 0,
-            unitsRemaining: creditsGranted,
-            costIncurredUsd: 0,
-            lastUsedAt: Date.now(),
-        });
-        return await ctx.db.get(purchaseId);
-    },
-});
-// Get all purchases for an agent
-export const getAgentPurchases = query({
-    args: { agentId: v.string() },
-    handler: async (ctx, args) => {
-        return await ctx.db
-            .query("purchases")
-            .withIndex("by_agentId", (q) => q.eq("agentId", args.agentId))
-            .collect();
-    },
-});
-// Get active purchase for a provider
-export const getActivePurchase = query({
-    args: {
-        agentId: v.string(),
-        providerId: v.string(),
-    },
-    handler: async (ctx, args) => {
-        const purchases = await ctx.db
-            .query("purchases")
-            .withIndex("by_agentId_providerId", (q) => q.eq("agentId", args.agentId).eq("providerId", args.providerId))
-            .collect();
-        return purchases.find((p) => p.status === "active") || null;
-    },
-});
-// Get usage for a purchase
-export const getUsage = query({
-    args: { purchaseId: v.id("purchases") },
-    handler: async (ctx, args) => {
-        return await ctx.db
-            .query("usage")
-            .withIndex("by_purchaseId", (q) => q.eq("purchaseId", args.purchaseId))
-            .first();
-    },
-});
-// Record usage
-export const recordUsage = mutation({
-    args: {
-        purchaseId: v.id("purchases"),
-        unitsUsed: v.number(),
-        costUsd: v.number(),
-    },
-    handler: async (ctx, args) => {
-        const usage = await ctx.db
-            .query("usage")
-            .withIndex("by_purchaseId", (q) => q.eq("purchaseId", args.purchaseId))
-            .first();
-        if (!usage) {
-            throw new Error("Usage record not found");
-        }
-        const newUnitsRemaining = Math.max(0, usage.unitsRemaining - args.unitsUsed);
-        await ctx.db.patch(usage._id, {
-            unitsUsed: usage.unitsUsed + args.unitsUsed,
-            unitsRemaining: newUnitsRemaining,
-            costIncurredUsd: usage.costIncurredUsd + args.costUsd,
-            lastUsedAt: Date.now(),
-        });
-        // Update purchase status if depleted
-        if (newUnitsRemaining === 0) {
-            const purchase = await ctx.db.get(args.purchaseId);
-            if (purchase) {
-                await ctx.db.patch(args.purchaseId, { status: "exhausted" });
-            }
-        }
-        return await ctx.db
-            .query("usage")
-            .withIndex("by_purchaseId", (q) => q.eq("purchaseId", args.purchaseId))
-            .first();
-    },
-});
-// Get balance summary for an agent
-export const getBalanceSummary = query({
-    args: { agentId: v.string() },
-    handler: async (ctx, args) => {
-        const credits = await ctx.db
-            .query("agentCredits")
-            .withIndex("by_agentId", (q) => q.eq("agentId", args.agentId))
-            .first();
-        const purchases = await ctx.db
-            .query("purchases")
-            .withIndex("by_agentId", (q) => q.eq("agentId", args.agentId))
-            .collect();
-        const activePurchases = purchases.filter((p) => p.status === "active");
-        const totalSpent = purchases.reduce((sum, p) => sum + p.amountUsd, 0);
-        return {
-            credits: credits || {
-                agentId: args.agentId,
-                balanceUsd: 0,
-                currency: "USD",
-            },
-            activePurchases,
-            totalSpentUsd: totalSpent,
-        };
-    },
-});

package/dist/convex/ratelimit.js

@@ -1,90 +0,0 @@
-import { mutation, query } from "./_generated/server";
-import { v } from "convex/values";
-// Rate limit config per tier
-const LIMITS = {
-    free: {
-        discovery: 100, // searches per hour
-        instant: 10, // API calls per hour
-    },
-    subscriber: {
-        discovery: 1000,
-        instant: 100,
-    },
-    provider: {
-        discovery: 10000,
-        instant: 1000,
-    },
-};
-// Check and increment rate limit
-export const checkLimit = mutation({
-    args: {
-        identifier: v.string(), // IP or agentId
-        action: v.union(v.literal("discovery"), v.literal("instant")),
-        tier: v.optional(v.union(v.literal("free"), v.literal("subscriber"), v.literal("provider"))),
-    },
-    handler: async (ctx, args) => {
-        const tier = args.tier || "free";
-        const limit = LIMITS[tier][args.action];
-        const hourKey = Math.floor(Date.now() / 3600000); // Hour bucket
-        const key = `${args.identifier}:${args.action}:${hourKey}`;
-        // Get current count
-        const existing = await ctx.db
-            .query("rateLimits")
-            .withIndex("by_key", (q) => q.eq("key", key))
-            .first();
-        if (existing) {
-            if (existing.count >= limit) {
-                return { allowed: false, remaining: 0, resetIn: 3600 - (Date.now() % 3600000) / 1000 };
-            }
-            await ctx.db.patch(existing._id, { count: existing.count + 1 });
-            return { allowed: true, remaining: limit - existing.count - 1 };
-        }
-        // Create new entry
-        await ctx.db.insert("rateLimits", {
-            key,
-            identifier: args.identifier,
-            action: args.action,
-            count: 1,
-            hourBucket: hourKey,
-            createdAt: Date.now(),
-        });
-        return { allowed: true, remaining: limit - 1 };
-    },
-});
-// Get current usage stats
-export const getUsage = query({
-    args: {
-        identifier: v.string(),
-    },
-    handler: async (ctx, args) => {
-        const hourKey = Math.floor(Date.now() / 3600000);
-        const discovery = await ctx.db
-            .query("rateLimits")
-            .withIndex("by_key", (q) => q.eq("key", `${args.identifier}:discovery:${hourKey}`))
-            .first();
-        const instant = await ctx.db
-            .query("rateLimits")
-            .withIndex("by_key", (q) => q.eq("key", `${args.identifier}:instant:${hourKey}`))
-            .first();
-        return {
-            discovery: discovery?.count || 0,
-            instant: instant?.count || 0,
-            limits: LIMITS.free,
-        };
-    },
-});
-// Cleanup old rate limit entries (run via cron)
-export const cleanup = mutation({
-    args: {},
-    handler: async (ctx) => {
-        const hourAgo = Math.floor(Date.now() / 3600000) - 2; // Keep 2 hours
-        const old = await ctx.db
-            .query("rateLimits")
-            .filter((q) => q.lt(q.field("hourBucket"), hourAgo))
-            .take(100);
-        for (const entry of old) {
-            await ctx.db.delete(entry._id);
-        }
-        return { deleted: old.length };
-    },
-});