@tuturuuu/ai 0.0.10

package/src/credits/resolve-plan-model.ts

@@ -0,0 +1,219 @@
+import { createAdminClient } from '@tuturuuu/supabase/next/server';
+import { getWorkspaceTier } from '@tuturuuu/utils/workspace-helper';
+import {
+  matchesAllowedModel,
+  normalizeStableModelId,
+  resolveGatewayModelId,
+} from './model-mapping';
+
+export type PlanModelCapability = 'image' | 'language';
+
+type WorkspaceProductTier = 'ENTERPRISE' | 'FREE' | 'PLUS' | 'PRO';
+
+type AllocationRow = {
+  allowed_models: string[];
+  default_image_model?: string | null;
+  default_language_model?: string | null;
+  id: string;
+  tier: WorkspaceProductTier;
+};
+
+type GatewayModelRow = {
+  id: string;
+  is_enabled: boolean;
+  type: PlanModelCapability;
+};
+
+export class PlanModelResolutionError extends Error {
+  code:
+    | 'DEFAULT_MODEL_DISABLED'
+    | 'DEFAULT_MODEL_INVALID'
+    | 'NO_ALLOCATION'
+    | 'WORKSPACE_ID_REQUIRED';
+
+  constructor(code: PlanModelResolutionError['code'], message: string) {
+    super(message);
+    this.name = 'PlanModelResolutionError';
+    this.code = code;
+  }
+}
+
+export interface EffectivePlanModel {
+  allocationId: string;
+  modelId: string;
+  source: 'plan_default' | 'requested';
+  tier: AllocationRow['tier'];
+}
+
+function getDefaultModelField(capability: PlanModelCapability) {
+  return capability === 'language'
+    ? 'default_language_model'
+    : 'default_image_model';
+}
+
+function getFallbackPlanModelId(
+  tier: WorkspaceProductTier,
+  capability: PlanModelCapability
+) {
+  if (capability === 'language') {
+    return 'google/gemini-3.1-flash-lite';
+  }
+
+  switch (tier) {
+    case 'FREE':
+      return 'google/imagen-4.0-fast-generate-001';
+    case 'PLUS':
+    case 'PRO':
+    case 'ENTERPRISE':
+      return 'google/imagen-4.0-generate-001';
+  }
+}
+
+export function selectEffectivePlanModel(args: {
+  allocation: AllocationRow;
+  capability: PlanModelCapability;
+  modelsById: Map<string, GatewayModelRow>;
+  requestedModel?: string | null;
+}): EffectivePlanModel {
+  const { allocation, capability, modelsById } = args;
+  const requestedModel = args.requestedModel?.trim()
+    ? resolveGatewayModelId(args.requestedModel)
+    : null;
+  const defaultModelId = normalizeStableModelId(
+    allocation[getDefaultModelField(capability)] ??
+      getFallbackPlanModelId(allocation.tier, capability)
+  );
+
+  if (requestedModel) {
+    const requestedRow = modelsById.get(requestedModel);
+    if (
+      requestedRow?.is_enabled &&
+      requestedRow.type === capability &&
+      matchesAllowedModel(requestedModel, allocation.allowed_models)
+    ) {
+      return {
+        allocationId: allocation.id,
+        modelId: requestedModel,
+        source: 'requested',
+        tier: allocation.tier,
+      };
+    }
+  }
+
+  const defaultRow = modelsById.get(defaultModelId);
+  if (!defaultRow) {
+    throw new PlanModelResolutionError(
+      'DEFAULT_MODEL_INVALID',
+      `Default ${capability} model "${defaultModelId}" is missing from ai_gateway_models.`
+    );
+  }
+
+  if (!defaultRow.is_enabled) {
+    throw new PlanModelResolutionError(
+      'DEFAULT_MODEL_DISABLED',
+      `Default ${capability} model "${defaultModelId}" is currently disabled.`
+    );
+  }
+
+  if (defaultRow.type !== capability) {
+    throw new PlanModelResolutionError(
+      'DEFAULT_MODEL_INVALID',
+      `Default ${capability} model "${defaultModelId}" has incompatible type "${defaultRow.type}".`
+    );
+  }
+
+  if (!matchesAllowedModel(defaultModelId, allocation.allowed_models)) {
+    throw new PlanModelResolutionError(
+      'DEFAULT_MODEL_INVALID',
+      `Default ${capability} model "${defaultModelId}" is not included in the allocation allowlist.`
+    );
+  }
+
+  return {
+    allocationId: allocation.id,
+    modelId: defaultModelId,
+    source: 'plan_default',
+    tier: allocation.tier,
+  };
+}
+
+export async function resolvePlanModel(args: {
+  capability: PlanModelCapability;
+  requestedModel?: string | null;
+  wsId?: string | null;
+}): Promise<EffectivePlanModel> {
+  if (!args.wsId) {
+    throw new PlanModelResolutionError(
+      'WORKSPACE_ID_REQUIRED',
+      'Workspace ID is required to resolve a plan model.'
+    );
+  }
+
+  const sbAdmin = await createAdminClient();
+  const privateDb = sbAdmin.schema('private');
+  const tier = await getWorkspaceTier(args.wsId, { useAdmin: true });
+
+  const { data: allocationData, error: allocationError } = await sbAdmin
+    .from('ai_credit_plan_allocations')
+    .select('*')
+    .eq('tier', tier)
+    .eq('is_active', true)
+    .maybeSingle();
+
+  if (allocationError) {
+    throw new PlanModelResolutionError(
+      'NO_ALLOCATION',
+      allocationError.message ||
+        `Failed to load AI credit allocation for ${tier}.`
+    );
+  }
+
+  const allocation = allocationData as AllocationRow | null;
+
+  if (!allocation) {
+    throw new PlanModelResolutionError(
+      'NO_ALLOCATION',
+      `No AI credit allocation configured for the ${tier} plan.`
+    );
+  }
+
+  const candidateIds = new Set<string>([
+    normalizeStableModelId(
+      allocation.default_language_model ??
+        getFallbackPlanModelId(allocation.tier, 'language')
+    ),
+    normalizeStableModelId(
+      allocation.default_image_model ??
+        getFallbackPlanModelId(allocation.tier, 'image')
+    ),
+  ]);
+
+  if (args.requestedModel?.trim()) {
+    candidateIds.add(resolveGatewayModelId(args.requestedModel));
+  }
+
+  const { data: models, error: modelsError } = await privateDb
+    .from('ai_gateway_models')
+    .select('id, type, is_enabled')
+    .in('id', Array.from(candidateIds));
+
+  if (modelsError) {
+    throw new PlanModelResolutionError(
+      'DEFAULT_MODEL_INVALID',
+      modelsError.message || 'Failed to load AI gateway model details.'
+    );
+  }
+
+  const modelsById = new Map(
+    ((models ?? []) as GatewayModelRow[]).map(
+      (model) => [model.id, model] as const
+    )
+  );
+
+  return selectEffectivePlanModel({
+    allocation,
+    capability: args.capability,
+    modelsById,
+    requestedModel: args.requestedModel,
+  });
+}

package/src/credits/sync-gateway-models.ts

@@ -0,0 +1,351 @@
+import type { SupabaseClient } from '@tuturuuu/supabase';
+import type { Json, TablesInsert } from '@tuturuuu/types';
+
+export type GatewayModelSyncSource =
+  | 'tuturuuu-production-public'
+  | 'vercel-gateway';
+
+type AIGatewayModelInsert = TablesInsert<
+  { schema: 'private' },
+  'ai_gateway_models'
+>;
+
+interface GatewayPricingTier {
+  cost: string;
+  min: number;
+  max?: number;
+}
+
+interface GatewayVideoDurationPricing {
+  resolution?: string;
+  cost_per_second: string;
+  audio?: boolean;
+  mode?: string;
+}
+
+interface GatewayModelPricing {
+  // Vercel AI Gateway uses these field names (values are strings)
+  input?: string;
+  output?: string;
+  input_cache_read?: string;
+  input_cache_write?: string;
+  web_search?: string;
+  image?: string;
+  input_tiers?: GatewayPricingTier[];
+  output_tiers?: GatewayPricingTier[];
+  input_cache_read_tiers?: GatewayPricingTier[];
+  input_cache_write_tiers?: GatewayPricingTier[];
+  video_duration_pricing?: GatewayVideoDurationPricing[];
+}
+
+interface GatewayModel {
+  id: string;
+  object: string;
+  created: number;
+  released?: number;
+  owned_by: string;
+  name: string;
+  description?: string;
+  context_window?: number;
+  max_tokens?: number;
+  type: 'language' | 'embedding' | 'image' | 'video' | string;
+  tags?: string[];
+  pricing?: GatewayModelPricing;
+}
+
+interface GatewayModelsResponse {
+  object: string;
+  data: GatewayModel[];
+}
+
+interface PublicGatewayModel {
+  cache_read_price_per_token?: number | string | null;
+  cache_write_price_per_token?: number | string | null;
+  context_window?: number | null;
+  description?: string | null;
+  id: string;
+  image_gen_price?: number | string | null;
+  input_price_per_token?: number | string | null;
+  input_tiers?: unknown;
+  is_enabled?: boolean | null;
+  max_tokens?: number | null;
+  name?: string | null;
+  output_price_per_token?: number | string | null;
+  output_tiers?: unknown;
+  pricing_raw?: unknown;
+  provider?: string | null;
+  released_at?: string | null;
+  search_price?: number | string | null;
+  synced_at?: string | null;
+  tags?: string[] | null;
+  type?: string | null;
+  web_search_price?: number | string | null;
+}
+
+interface PublicModelsResponse {
+  data?: PublicGatewayModel[];
+  pagination?: {
+    limit: number;
+    page: number;
+    total: number;
+  };
+}
+
+interface SyncResult {
+  synced: number;
+  new: number;
+  updated: number;
+  errors: string[];
+}
+
+const GATEWAY_URL = 'https://ai-gateway.vercel.sh/v1/models';
+const TUTURUUU_PRODUCTION_PUBLIC_MODELS_URL =
+  'https://tuturuuu.com/api/v1/infrastructure/ai/models';
+const PUBLIC_MODELS_PAGE_SIZE = 100;
+const UPSERT_BATCH_SIZE = 100;
+const SELECT_BATCH_SIZE = 1000;
+
+function isImageGenModelId(id: string): boolean {
+  return (
+    id.startsWith('google/imagen-') || id === 'google/gemini-2.5-flash-image'
+  );
+}
+
+function toNumber(value: number | string | null | undefined): number {
+  if (value === null || value === undefined) return 0;
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : 0;
+}
+
+function toNullableNumber(
+  value: number | string | null | undefined
+): number | null {
+  if (value === null || value === undefined) return null;
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+
+function toNullableJson(value: unknown): Json | null {
+  return value === null || value === undefined ? null : (value as Json);
+}
+
+function resolveGatewayModelMaxTokens(
+  id: string,
+  maxTokens: number | null | undefined
+): number | null {
+  if (id === 'google/gemini-embedding-2') {
+    return 3072;
+  }
+
+  return maxTokens ?? null;
+}
+
+async function fetchVercelGatewayModels(): Promise<GatewayModel[]> {
+  const response = await fetch(GATEWAY_URL);
+  if (!response.ok) {
+    throw new Error(
+      `Failed to fetch gateway models: ${response.status} ${response.statusText}`
+    );
+  }
+
+  const json = (await response.json()) as unknown;
+
+  return Array.isArray(json)
+    ? (json as GatewayModel[])
+    : ((json as GatewayModelsResponse | undefined)?.data ?? []);
+}
+
+async function fetchTuturuuuProductionPublicModels(): Promise<
+  PublicGatewayModel[]
+> {
+  const models: PublicGatewayModel[] = [];
+
+  for (let page = 1; page <= 100; page++) {
+    const url = new URL(TUTURUUU_PRODUCTION_PUBLIC_MODELS_URL);
+    url.searchParams.set('format', 'paginated');
+    url.searchParams.set('limit', String(PUBLIC_MODELS_PAGE_SIZE));
+    url.searchParams.set('page', String(page));
+    url.searchParams.set('type', 'all');
+
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(
+        `Failed to fetch Tuturuuu production public models: ${response.status} ${response.statusText}`
+      );
+    }
+
+    const json = (await response.json()) as
+      | PublicGatewayModel[]
+      | PublicModelsResponse;
+
+    if (Array.isArray(json)) {
+      return json;
+    }
+
+    const pageModels = Array.isArray(json.data) ? json.data : [];
+    models.push(...pageModels);
+
+    const total = json.pagination?.total;
+    if (
+      pageModels.length < PUBLIC_MODELS_PAGE_SIZE ||
+      (typeof total === 'number' && models.length >= total)
+    ) {
+      break;
+    }
+  }
+
+  return models;
+}
+
+async function fetchExistingModelIds(
+  sbAdmin: SupabaseClient
+): Promise<Set<string>> {
+  const existingIdSet = new Set<string>();
+  const privateDb = sbAdmin.schema('private');
+
+  for (let from = 0; ; from += SELECT_BATCH_SIZE) {
+    const { data, error } = await privateDb
+      .from('ai_gateway_models')
+      .select('id')
+      .range(from, from + SELECT_BATCH_SIZE - 1);
+
+    if (error) {
+      throw new Error(
+        `Failed to fetch existing gateway models: ${error.message}`
+      );
+    }
+
+    for (const row of (data ?? []) as Array<{ id: string }>) {
+      existingIdSet.add(row.id);
+    }
+
+    if (!data || data.length < SELECT_BATCH_SIZE) {
+      break;
+    }
+  }
+
+  return existingIdSet;
+}
+
+function mapVercelGatewayModel(m: GatewayModel): AIGatewayModelInsert {
+  const provider = m.owned_by || m.id.split('/')[0] || 'unknown';
+  const modelName = m.id.split('/').slice(1).join('/') || m.id;
+
+  return {
+    id: m.id,
+    name: m.name || modelName,
+    provider,
+    description: m.description || null,
+    type: m.type || 'language',
+    context_window: m.context_window ?? null,
+    max_tokens: resolveGatewayModelMaxTokens(m.id, m.max_tokens),
+    tags: m.tags ?? [],
+    input_price_per_token: parseFloat(m.pricing?.input ?? '0'),
+    output_price_per_token: parseFloat(m.pricing?.output ?? '0'),
+    input_tiers: toNullableJson(m.pricing?.input_tiers),
+    output_tiers: toNullableJson(m.pricing?.output_tiers),
+    cache_read_price_per_token: m.pricing?.input_cache_read
+      ? parseFloat(m.pricing.input_cache_read)
+      : null,
+    cache_write_price_per_token: m.pricing?.input_cache_write
+      ? parseFloat(m.pricing.input_cache_write)
+      : null,
+    web_search_price: m.pricing?.web_search
+      ? parseFloat(m.pricing.web_search)
+      : null,
+    // Use gateway image price when present; fallback for known image models so credit deduction stays correct
+    image_gen_price: m.pricing?.image
+      ? parseFloat(m.pricing.image)
+      : isImageGenModelId(m.id)
+        ? 0.0001
+        : null,
+    released_at: m.released ? new Date(m.released * 1000).toISOString() : null,
+    pricing_raw: toNullableJson(m.pricing),
+    synced_at: new Date().toISOString(),
+  };
+}
+
+function mapTuturuuuProductionPublicModel(
+  m: PublicGatewayModel
+): AIGatewayModelInsert {
+  const provider = m.provider || m.id.split('/')[0] || 'unknown';
+  const modelName = m.id.split('/').slice(1).join('/') || m.id;
+
+  return {
+    id: m.id,
+    name: m.name || modelName,
+    provider,
+    description: m.description ?? null,
+    type: m.type || 'language',
+    context_window: m.context_window ?? null,
+    max_tokens: resolveGatewayModelMaxTokens(m.id, m.max_tokens),
+    tags: m.tags ?? [],
+    input_price_per_token: toNumber(m.input_price_per_token),
+    output_price_per_token: toNumber(m.output_price_per_token),
+    input_tiers: toNullableJson(m.input_tiers),
+    output_tiers: toNullableJson(m.output_tiers),
+    cache_read_price_per_token: toNullableNumber(m.cache_read_price_per_token),
+    cache_write_price_per_token: toNullableNumber(
+      m.cache_write_price_per_token
+    ),
+    web_search_price: toNullableNumber(m.web_search_price),
+    image_gen_price:
+      toNullableNumber(m.image_gen_price) ??
+      (isImageGenModelId(m.id) ? 0.0001 : null),
+    released_at: m.released_at ?? null,
+    pricing_raw: toNullableJson(m.pricing_raw),
+    search_price: toNullableNumber(m.search_price),
+    synced_at: new Date().toISOString(),
+    ...(typeof m.is_enabled === 'boolean' ? { is_enabled: m.is_enabled } : {}),
+  };
+}
+
+/**
+ * Fetches model data from the selected catalog and upserts into ai_gateway_models.
+ * Vercel Gateway sync preserves enablement; production-public sync mirrors it
+ * when the public catalog includes is_enabled.
+ */
+export async function syncGatewayModels(
+  sbAdmin: SupabaseClient,
+  options: { source?: GatewayModelSyncSource } = {}
+): Promise<SyncResult> {
+  const result: SyncResult = { synced: 0, new: 0, updated: 0, errors: [] };
+  const source = options.source ?? 'vercel-gateway';
+
+  const rows =
+    source === 'tuturuuu-production-public'
+      ? (await fetchTuturuuuProductionPublicModels()).map(
+          mapTuturuuuProductionPublicModel
+        )
+      : (await fetchVercelGatewayModels()).map(mapVercelGatewayModel);
+
+  if (rows.length === 0) {
+    result.errors.push('No models returned from gateway');
+    return result;
+  }
+
+  const existingIdSet = await fetchExistingModelIds(sbAdmin);
+  const privateDb = sbAdmin.schema('private');
+
+  for (let i = 0; i < rows.length; i += UPSERT_BATCH_SIZE) {
+    const batch = rows.slice(i, i + UPSERT_BATCH_SIZE);
+    const { error } = await privateDb
+      .from('ai_gateway_models')
+      .upsert(batch, { onConflict: 'id' });
+
+    if (error) {
+      result.errors.push(`Batch ${i / UPSERT_BATCH_SIZE}: ${error.message}`);
+    } else {
+      for (const row of batch) {
+        result.synced++;
+        if (existingIdSet.has(row.id)) {
+          result.updated++;
+        } else {
+          result.new++;
+        }
+      }
+    }
+  }
+
+  return result;
+}

package/src/credits/types.ts

@@ -0,0 +1,109 @@
+import type {
+  AiFeature,
+  CreditErrorCode,
+} from '@tuturuuu/ai/credits/constants';
+
+export type { AiFeature, CreditErrorCode };
+
+export interface CreditCheckResult {
+  allowed: boolean;
+  remainingCredits: number;
+  tier: string;
+  maxOutputTokens: number | null;
+  errorCode: CreditErrorCode | null;
+  errorMessage: string | null;
+}
+
+export interface CreditDeductionResult {
+  success: boolean;
+  creditsDeducted: number;
+  remainingCredits: number;
+  errorCode: string | null;
+}
+
+export interface CreditReservationResult {
+  success: boolean;
+  reservationId: string | null;
+  remainingCredits: number;
+  errorCode: string | null;
+}
+
+export interface CreditReservationCommitResult {
+  success: boolean;
+  creditsDeducted: number;
+  remainingCredits: number;
+  errorCode: string | null;
+}
+
+export interface CreditReservationReleaseResult {
+  success: boolean;
+  remainingCredits: number;
+  errorCode: string | null;
+}
+
+export interface MeteredEmbeddingReservationResult {
+  success: boolean;
+  reservationId: string | null;
+  creditsReserved: number;
+  costUsd: number;
+  remainingCredits: number;
+  errorCode: string | null;
+}
+
+export interface AiCreditStatus {
+  totalAllocated: number;
+  totalUsed: number;
+  remaining: number;
+  bonusCredits: number;
+  percentUsed: number;
+  periodStart: string;
+  periodEnd: string;
+  tier: string;
+  allowedModels: string[];
+  allowedFeatures: string[];
+  defaultImageModel: string;
+  defaultLanguageModel: string;
+  dailyLimit: number | null;
+  dailyUsed: number;
+  maxOutputTokens: number | null;
+  balanceScope: 'user' | 'workspace';
+  seatCount: number | null;
+}
+
+export interface CreditAllocation {
+  tier: string;
+  monthlyCredits: number;
+  dailyLimit: number | null;
+  weeklyLimit: number | null;
+  maxCreditsPerRequest: number | null;
+  maxOutputTokensPerRequest: number | null;
+  markupMultiplier: number;
+  allowedModels: string[];
+  allowedFeatures: string[];
+  defaultImageModel: string;
+  defaultLanguageModel: string;
+  maxRequestsPerDay: number | null;
+  isActive: boolean;
+}
+
+export interface FeatureAccess {
+  tier: string;
+  feature: AiFeature;
+  enabled: boolean;
+  maxRequestsPerDay: number | null;
+}
+
+export interface DeductCreditsParams {
+  wsId?: string;
+  userId?: string;
+  modelId: string;
+  inputTokens: number;
+  outputTokens: number;
+  reasoningTokens?: number;
+  imageCount?: number;
+  searchCount?: number;
+  feature: AiFeature;
+  executionId?: string;
+  chatMessageId?: string;
+  metadata?: Record<string, unknown>;
+}

package/src/credits/use-ai-credits.ts

@@ -0,0 +1,3 @@
+// Client-side hooks for AI credits live in @tuturuuu/ui/hooks/use-ai-credits
+// This file re-exports types only for backward compatibility
+export type { AiCreditStatus } from './types';