@nordsym/apiclaw 2.2.0 → 2.2.1

package/convex/purchases.ts

@@ -1,183 +0,0 @@
-import { v } from "convex/values";
-import { mutation, query } from "./_generated/server";
-
-// Provider pricing (credits per dollar)
-const CREDITS_PER_DOLLAR: Record<string, number> = {
-  "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: string, amountUsd: number): number {
-  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/convex/ratelimit.ts

@@ -1,104 +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 };
-  },
-});