Antigravity マルチエージェントで継続課金 SaaS を作る — エージェント分担と購読収益の実装パターン

// オーケストレータの最小実装
import { Agent, AgentSession } from "@antigravity/sdk";
 
interface OrchestrationRequest {
  userId: string;
  taskType: "daily_summary" | "weekly_report" | "watchlist_alert";
  payload: Record<string, unknown>;
}
 
async function orchestrate(env: Env, req: OrchestrationRequest): Promise<{ status: string; resultId: string }> {
  const session = new AgentSession({ apiKey: env.ANTIGRAVITY_API_KEY });
  // 1. 利用量チェック（Stripeサブスク状態と連動）
  const allowed = await checkSubscriptionQuota(env, req.userId, req.taskType);
  if (!allowed) {
    return { status: "quota_exceeded", resultId: "" };
  }
  // 2. タスク種別に応じた専門エージェントの呼び出し
  let result: string;
  try {
    switch (req.taskType) {
      case "daily_summary":
        result = await dailySummaryAgent(session, req.payload);
        break;
      case "weekly_report":
        result = await weeklyReportAgent(session, req.payload);
        break;
      case "watchlist_alert":
        result = await watchlistAgent(session, req.payload);
        break;
    }
    // 3. 監視エージェントによる品質チェック
    const qualityOk = await qualityCheckAgent(session, result);
    if (!qualityOk) {
      // 品質不十分なら、フォールバック生成へ
      result = await fallbackAgent(session, req.payload);
    }
    // 4. 結果保存とユーザー通知
    const resultId = await persistResult(env, req.userId, req.taskType, result);
    return { status: "success", resultId };
  } catch (error) {
    console.error("orchestrate failed:", error);
    return { status: "error", resultId: "" };
  }
}

// 冪等キーつきのタスク実行
import { z } from "zod";
 
const TaskSchema = z.object({
  userId: z.string(),
  taskType: z.string(),
  scheduleDate: z.string(), // YYYY-MM-DD
  payload: z.record(z.unknown()),
});
 
type Task = z.infer<typeof TaskSchema>;
 
async function runScheduledTask(env: Env, task: Task): Promise<{ status: string }> {
  // 冪等キー = userId + taskType + scheduleDate
  const idempotencyKey = `task:${task.userId}:${task.taskType}:${task.scheduleDate}`;
  const existing = await env.TASK_KV.get(idempotencyKey);
  if (existing) {
    // すでに実行済み: 重複実行をスキップ
    return { status: "already_executed" };
  }
  // ロックを先に取得（実行中も他から見える）
  await env.TASK_KV.put(idempotencyKey, "running", { expirationTtl: 3600 });
 
  try {
    const result = await orchestrate(env, task);
    await env.TASK_KV.put(idempotencyKey, JSON.stringify(result), { expirationTtl: 60 * 60 * 24 * 7 });
    return { status: "success" };
  } catch (error) {
    // ロックは1時間で自動失効するので、リトライ可能
    console.error("task failed:", error);
    await env.TASK_KV.delete(idempotencyKey);
    throw error;
  }
}

// プランごとの利用上限定義
interface PlanLimits {
  monthlyTaskLimit: number;
  monthlyCostLimitJpy: number;
}
 
const PLAN_LIMITS: Record<string, PlanLimits> = {
  starter: { monthlyTaskLimit: 30, monthlyCostLimitJpy: 500 },
  standard: { monthlyTaskLimit: 100, monthlyCostLimitJpy: 1500 },
  plus: { monthlyTaskLimit: 300, monthlyCostLimitJpy: 4000 },
};
 
async function checkSubscriptionQuota(
  env: Env,
  userId: string,
  taskType: string
): Promise<boolean> {
  const subscription = await getActiveSubscription(env, userId);
  if (!subscription) return false;
  const limits = PLAN_LIMITS[subscription.planId];
  if (!limits) return false;
 
  const month = new Date().toISOString().slice(0, 7);
  const usageKey = `usage:${userId}:${month}`;
  const usage = await env.USAGE_KV.get(usageKey, "json") as { taskCount: number; costJpy: number } | null;
  const current = usage ?? { taskCount: 0, costJpy: 0 };
 
  if (current.taskCount >= limits.monthlyTaskLimit) return false;
  if (current.costJpy >= limits.monthlyCostLimitJpy) return false;
  return true;
}
 
async function recordUsage(env: Env, userId: string, costJpy: number): Promise<void> {
  const month = new Date().toISOString().slice(0, 7);
  const usageKey = `usage:${userId}:${month}`;
  const usage = await env.USAGE_KV.get(usageKey, "json") as { taskCount: number; costJpy: number } | null;
  const next = {
    taskCount: (usage?.taskCount ?? 0) + 1,
    costJpy: (usage?.costJpy ?? 0) + costJpy,
  };
  await env.USAGE_KV.put(usageKey, JSON.stringify(next), { expirationTtl: 60 * 60 * 24 * 35 });
}

// オーバーレート分を Stripe に記録
import Stripe from "stripe";
 
async function reportOverageUsage(env: Env, userId: string, overageCount: number): Promise<void> {
  if (overageCount <= 0) return;
  const stripe = new Stripe(env.STRIPE_SECRET_KEY, { apiVersion: "2025-09-30.clover" });
  const subscriptionItemId = await getMeteredItemId(env, userId);
  await stripe.subscriptionItems.createUsageRecord(subscriptionItemId, {
    quantity: overageCount,
    timestamp: Math.floor(Date.now() / 1000),
    action: "increment",
  });
}

async function handleCancelIntent(env: Env, userId: string, reason: string): Promise<{ action: string }> {
  const stripe = new Stripe(env.STRIPE_SECRET_KEY, { apiVersion: "2025-09-30.clover" });
  const usage = await getRecentUsage(env, userId, 30);
 
  if (reason === "not_using" && usage.taskCount < 5) {
    const subId = await getSubId(env, userId);
    await stripe.subscriptions.update(subId, {
      pause_collection: {
        behavior: "void",
        resumes_at: Math.floor(Date.now() / 1000) + 30 * 86400,
      },
    });
    return { action: "paused_for_30_days" };
  }
  if (reason === "too_expensive") {
    const subId = await getSubId(env, userId);
    await stripe.subscriptions.update(subId, { coupon: "RETENTION_30PCT_60D" });
    return { action: "discount_30pct_60d" };
  }
  return { action: "cancel_proceed" };
}