@tuturuuu/ai 0.0.10

package/src/generate/route.ts

@@ -0,0 +1,411 @@
+import { google } from '@ai-sdk/google';
+import { capMaxOutputTokensByCredits } from '@tuturuuu/ai/credits/cap-output-tokens';
+import {
+  checkAiCredits,
+  deductAiCredits,
+} from '@tuturuuu/ai/credits/check-credits';
+import { toBareModelName } from '@tuturuuu/ai/credits/model-mapping';
+import {
+  PlanModelResolutionError,
+  resolvePlanModel,
+} from '@tuturuuu/ai/credits/resolve-plan-model';
+import { createAdminClient } from '@tuturuuu/supabase/next/server';
+import { ROOT_WORKSPACE_ID } from '@tuturuuu/utils/constants';
+import { type FinishReason, streamText } from 'ai';
+import { type NextRequest, NextResponse } from 'next/server';
+import { validateApiKeyHash } from '../api-key-hash';
+import { withAiMemory } from '../memory';
+
+const ALLOWED_MODELS = [
+  {
+    name: 'gemini-2.0-flash',
+    price: {
+      per1MInputTokens: 0.1,
+      per1MOutputTokens: 0.4,
+      per1MReasoningTokens: 0.4,
+    },
+  },
+  {
+    name: 'gemini-2.0-flash-lite',
+    price: {
+      per1MInputTokens: 0.075,
+      per1MOutputTokens: 0.3,
+      per1MReasoningTokens: 0.3,
+    },
+  },
+  {
+    name: 'gemini-2.5-flash',
+    price: {
+      per1MInputTokens: 0.3,
+      per1MOutputTokens: 2.5,
+      per1MReasoningTokens: 2.5,
+    },
+  },
+  {
+    name: 'gemini-2.5-flash-lite',
+    price: {
+      per1MInputTokens: 0.1,
+      per1MOutputTokens: 0.4,
+      per1MReasoningTokens: 0.4,
+    },
+  },
+  {
+    name: 'gemini-2.5-pro',
+    price: {
+      per1MInputTokens: 1.25,
+      per1MOutputTokens: 10,
+      per1MReasoningTokens: 10,
+    },
+  },
+] as const satisfies {
+  name: string;
+  price: {
+    per1MInputTokens: number;
+    per1MOutputTokens: number;
+    per1MReasoningTokens: number;
+  };
+}[];
+
+export function createPOST(
+  _options: { serverAPIKeyFallback?: boolean } = {
+    serverAPIKeyFallback: false,
+  }
+) {
+  // Higher-order function that returns the actual request handler
+  return async function handler(req: NextRequest): Promise<Response> {
+    const sbAdmin = await createAdminClient();
+
+    const {
+      prompt,
+      accessKey,
+      configs = {
+        wsId: ROOT_WORKSPACE_ID,
+        model: 'gemini-2.0-flash-lite',
+        systemPrompt: '',
+        thinkingBudget: 0,
+        includeThoughts: false,
+      },
+    } = (await req.json()) as {
+      prompt?: string;
+      dataType?: 'text' | 'file' | 'image';
+      mimeType?: string;
+      accessKey?: {
+        id: string;
+        value: string;
+      };
+      configs?: {
+        wsId: string;
+        model: (typeof ALLOWED_MODELS)[number]['name'];
+        systemPrompt?: string;
+        thinkingBudget?: number;
+        includeThoughts?: boolean;
+      };
+    };
+
+    if (!configs?.wsId) {
+      configs.wsId = ROOT_WORKSPACE_ID;
+    }
+
+    if (!configs?.systemPrompt) {
+      configs.systemPrompt = '';
+    }
+
+    if (!configs?.thinkingBudget) {
+      configs.thinkingBudget = 0;
+    }
+
+    if (!configs?.includeThoughts) {
+      configs.includeThoughts = false;
+    }
+
+    try {
+      if (!accessKey?.id || !accessKey?.value) {
+        console.error('Missing accessId or accessKey');
+        return new Response('Missing accessId or accessKey', { status: 400 });
+      }
+
+      if (!prompt) {
+        console.error('Missing prompt');
+        return new Response('Missing prompt', { status: 400 });
+      }
+
+      let effectiveModel = configs.model;
+      try {
+        const resolvedModel = await resolvePlanModel({
+          capability: 'language',
+          requestedModel: configs.model,
+          wsId: configs.wsId,
+        });
+        effectiveModel = toBareModelName(
+          resolvedModel.modelId
+        ) as (typeof ALLOWED_MODELS)[number]['name'];
+        configs.model = effectiveModel;
+      } catch (error) {
+        if (error instanceof PlanModelResolutionError) {
+          const status = error.code === 'NO_ALLOCATION' ? 503 : 500;
+          return NextResponse.json(
+            { error: error.message, code: error.code },
+            { status }
+          );
+        }
+
+        throw error;
+      }
+
+      // Pre-flight AI credit check (no userId available for API key auth)
+      const creditCheck = await checkAiCredits(
+        configs.wsId,
+        effectiveModel,
+        'generate'
+      );
+      if (!creditCheck.allowed) {
+        return NextResponse.json(
+          {
+            error: creditCheck.errorMessage || 'AI credits insufficient',
+            code: creditCheck.errorCode,
+          },
+          { status: 403 }
+        );
+      }
+
+      if (!effectiveModel) {
+        console.error('Missing model');
+        return new Response('Missing model', { status: 400 });
+      }
+
+      if (!ALLOWED_MODELS.some((model) => model.name === effectiveModel)) {
+        console.error('Invalid model');
+        return new Response(
+          `Invalid model: ${effectiveModel}\nAllowed models: ${ALLOWED_MODELS.map((model) => model.name).join(', ')}`,
+          { status: 400 }
+        );
+      }
+
+      if (!configs.wsId) {
+        console.error('Missing workspace ID');
+        return new Response('Missing workspace ID', { status: 400 });
+      }
+
+      const { data: apiKeyData, error: apiKeyError } = await sbAdmin
+        .from('workspace_api_keys')
+        .select('id, created_by, scopes, key_hash')
+        .eq('ws_id', configs.wsId)
+        .eq('id', accessKey.id)
+        .single();
+
+      const isValidAccessKey =
+        !apiKeyError &&
+        !!apiKeyData?.key_hash &&
+        (await validateApiKeyHash(accessKey.value, apiKeyData.key_hash));
+
+      if (!isValidAccessKey || !apiKeyData) {
+        console.error('Invalid accessId or accessKey', apiKeyError);
+        return new Response('Invalid accessId or accessKey', { status: 400 });
+      }
+
+      if (!apiKeyData.scopes.includes(effectiveModel)) {
+        console.error('Invalid model');
+        return new Response(
+          `Invalid model: ${effectiveModel}\nAllowed models: ${apiKeyData.scopes.join(', ')}`,
+          { status: 400 }
+        );
+      }
+
+      const apiKeyId = apiKeyData.id;
+
+      let result: {
+        input: string;
+        output: string;
+        usage: {
+          inputTokens: number;
+          outputTokens: number;
+          reasoningTokens: number;
+          totalTokens: number;
+        };
+        finishReason: FinishReason;
+      } | null = null;
+
+      // Apply credit-budget cap on maxOutputTokens (defense-in-depth)
+      const cappedMaxOutput = await capMaxOutputTokensByCredits(
+        sbAdmin,
+        effectiveModel,
+        creditCheck.maxOutputTokens,
+        creditCheck.remainingCredits
+      );
+      if (cappedMaxOutput === null && creditCheck.remainingCredits <= 0) {
+        return NextResponse.json(
+          { error: 'AI credits insufficient', code: 'CREDITS_EXHAUSTED' },
+          { status: 403 }
+        );
+      }
+
+      const stream = streamText({
+        model: await withAiMemory({
+          customId: `generate-${apiKeyId}-${Date.now()}`,
+          model: google(effectiveModel),
+          product: 'ai_chat',
+          source: 'api_generate',
+          surface: 'api_generate',
+          userId: apiKeyData.created_by,
+          wsId: configs.wsId,
+        }),
+        prompt,
+        system: configs.systemPrompt,
+        ...(cappedMaxOutput ? { maxOutputTokens: cappedMaxOutput } : {}),
+        onFinish: async ({ text, finishReason, usage }) => {
+          result = {
+            input: prompt,
+            output: text,
+            usage: {
+              inputTokens: usage.inputTokens ?? 0,
+              outputTokens: usage.outputTokens ?? 0,
+              reasoningTokens: usage.reasoningTokens ?? 0,
+              totalTokens: usage.totalTokens ?? 0,
+            },
+            finishReason,
+          };
+
+          const insertData = {
+            ws_id: configs.wsId,
+            api_key_id: apiKeyId,
+            model_id: effectiveModel,
+            input: prompt,
+            output: text,
+            finish_reason: String(finishReason),
+            input_tokens: usage.inputTokens ?? 0,
+            output_tokens: usage.outputTokens ?? 0,
+            reasoning_tokens: usage.reasoningTokens ?? 0,
+            total_tokens: usage.totalTokens ?? 0,
+            system_prompt: configs.systemPrompt ?? '',
+          };
+
+          const { data: execData, error: saveError } = await sbAdmin
+            .from('workspace_ai_executions')
+            .insert(insertData)
+            .select('id')
+            .single();
+
+          if (saveError) {
+            console.error('Error saving AI execution');
+            console.error(saveError);
+          }
+
+          // Deduct AI credits (no userId for API key auth)
+          deductAiCredits({
+            wsId: configs.wsId,
+            modelId: effectiveModel,
+            inputTokens: usage.inputTokens ?? 0,
+            outputTokens: usage.outputTokens ?? 0,
+            reasoningTokens:
+              usage.outputTokenDetails?.reasoningTokens ??
+              usage.reasoningTokens ??
+              0,
+            feature: 'generate',
+            executionId: execData?.id,
+          }).catch((err) => console.error('Failed to deduct AI credits:', err));
+        },
+        providerOptions: {
+          google: {
+            responseModalities: ['TEXT'],
+            thinkingConfig: {
+              thinkingBudget: configs.thinkingBudget ?? 0,
+              includeThoughts: configs.includeThoughts ?? false,
+            },
+          },
+        },
+      });
+
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      for await (const _ of stream.textStream) {
+        // console.log(textPart);
+      }
+
+      // Calculate the cost of the request
+      const model = ALLOWED_MODELS.find(
+        (model) => model.name === effectiveModel
+      );
+      if (!model) {
+        console.error('Invalid model');
+        return new Response('Invalid model', { status: 400 });
+      }
+
+      if (!result) {
+        console.error('No result');
+        return new Response('No result', { status: 400 });
+      }
+
+      const typedResult = result as {
+        input: string;
+        output: string;
+        usage: {
+          inputTokens: number;
+          outputTokens: number;
+          reasoningTokens: number;
+          totalTokens: number;
+        };
+        finishReason: FinishReason;
+      };
+
+      const cost = {
+        inputCost:
+          (typedResult.usage.inputTokens / 1_000_000) *
+          model.price.per1MInputTokens,
+        outputCost:
+          (typedResult.usage.outputTokens / 1_000_000) *
+          model.price.per1MOutputTokens,
+        reasoningCost:
+          (typedResult.usage.reasoningTokens / 1_000_000) *
+          model.price.per1MReasoningTokens,
+      };
+
+      const totalCostUSD =
+        cost.inputCost + cost.outputCost + cost.reasoningCost;
+
+      // Fetch dynamic USD→VND exchange rate via DB function, fallback to 26000
+      let exchangeRate = 26000;
+      try {
+        const { data: rate } = await sbAdmin.rpc('get_exchange_rate', {
+          p_from_currency: 'USD',
+          p_to_currency: 'VND',
+        });
+        if (rate && Number(rate) > 0) {
+          exchangeRate = Number(rate);
+        }
+      } catch {
+        // Use fallback rate
+      }
+      const totalCostVND = totalCostUSD * exchangeRate;
+
+      // Format VND cost: show up to 3 decimal places if under 1 VND, otherwise whole number
+      const formattedVNDCost =
+        totalCostVND < 1
+          ? `${totalCostVND.toFixed(3)} VND`
+          : `${totalCostVND.toFixed(0)} VND`;
+
+      return NextResponse.json({
+        ...typedResult,
+        cost: {
+          inputCost: `$${cost.inputCost.toFixed(8)}`,
+          outputCost: `$${cost.outputCost.toFixed(8)}`,
+          reasoningCost: `$${cost.reasoningCost.toFixed(8)}`,
+          totalCost: `$${totalCostUSD.toFixed(8)}`,
+          totalCostVND: formattedVNDCost,
+        },
+      });
+    } catch (error) {
+      if (error instanceof Error) {
+        console.log(error.message);
+        return NextResponse.json(
+          {
+            message: `## Edge API Failure\nCould not complete the request. Please view the **Stack trace** below.\n\`\`\`bash\n${error instanceof Error ? error.stack : 'Unknown error'}`,
+          },
+          {
+            status: 500,
+          }
+        );
+      }
+      console.log(error);
+      return new Response('Internal Server Error', { status: 500 });
+    }
+  };
+}

package/src/hooks.ts

@@ -0,0 +1,7 @@
+import {
+  useChat,
+  useCompletion,
+  experimental_useObject as useObject,
+} from '@ai-sdk/react';
+
+export { useChat, useCompletion, useObject };

package/src/meetings/summary/route.ts

@@ -0,0 +1,7 @@
+export function createPOST(
+  _options: { serverAPIKeyFallback?: boolean } = {
+    serverAPIKeyFallback: false,
+  }
+) {
+  return async function handler(_req: Request) {};
+}

package/src/meetings/transcription/route.ts

@@ -0,0 +1,134 @@
+import { google } from '@ai-sdk/google';
+import { createClient } from '@tuturuuu/supabase/next/server';
+import { generateObject } from 'ai';
+import { z } from 'zod';
+import { withAiMemory } from '../../memory';
+
+const DEFAULT_MODEL_NAME = 'gemini-3.1-flash-lite';
+
+const transcriptSchema = z.object({
+  text: z.string().describe('The full transcript text'),
+  segments: z
+    .array(
+      z.object({
+        text: z.string().describe('Text content of this segment'),
+        start: z.number().describe('Start time in seconds'),
+        end: z.number().describe('End time in seconds'),
+      })
+    )
+    .optional()
+    .describe('Array of transcript segments with timestamps'),
+  language: z
+    .string()
+    .optional()
+    .describe('Detected language code (e.g. "en", "vi")'),
+  durationInSeconds: z
+    .number()
+    .optional()
+    .describe('Total audio duration in seconds'),
+});
+
+export function createPOST() {
+  return async function handler(req: Request) {
+    try {
+      const supabase = await createClient();
+
+      const {
+        data: { user },
+      } = await supabase.auth.getUser();
+
+      if (!user) {
+        console.error('Unauthorized');
+        return new Response('Unauthorized', { status: 401 });
+      }
+
+      const formData = await req.formData();
+      const audioFile = formData.get('audio') as File;
+      const wsId = formData.get('wsId') as string | null;
+
+      if (!audioFile) {
+        return new Response('No audio file provided', { status: 400 });
+      }
+
+      // Convert file to buffer
+      const audioBuffer = await audioFile.arrayBuffer();
+      const audioUint8Array = new Uint8Array(audioBuffer);
+
+      const result = await generateObject({
+        model: await withAiMemory({
+          addMemory: 'never',
+          customId: `meeting-transcription-${Date.now()}`,
+          model: google(DEFAULT_MODEL_NAME),
+          product: 'meetings',
+          source: 'meeting_transcription',
+          surface: 'meeting_transcription',
+          userId: user.id,
+          wsId,
+        }),
+        schema: transcriptSchema,
+        system: systemInstruction,
+        messages: [
+          {
+            role: 'user',
+            content: [
+              {
+                type: 'file',
+                mediaType: 'audio/mpeg',
+                data: audioUint8Array,
+              },
+            ],
+          },
+        ],
+        providerOptions: {
+          google: {
+            safetySettings: [
+              {
+                category: 'HARM_CATEGORY_DANGEROUS_CONTENT',
+                threshold: 'BLOCK_NONE',
+              },
+              {
+                category: 'HARM_CATEGORY_HATE_SPEECH',
+                threshold: 'BLOCK_NONE',
+              },
+              {
+                category: 'HARM_CATEGORY_HARASSMENT',
+                threshold: 'BLOCK_NONE',
+              },
+              {
+                category: 'HARM_CATEGORY_SEXUALLY_EXPLICIT',
+                threshold: 'BLOCK_NONE',
+              },
+            ],
+          },
+        },
+      });
+
+      return new Response(
+        JSON.stringify({
+          text: result.object.text,
+          segments: result.object.segments,
+          language: result.object.language,
+          durationInSeconds: result.object.durationInSeconds,
+        }),
+        {
+          headers: { 'Content-Type': 'application/json' },
+        }
+      );
+    } catch (error) {
+      console.error('Transcription error:', error);
+      return new Response('Internal server error', { status: 500 });
+    }
+  };
+}
+
+const systemInstruction = `
+  You are a helpful assistant that transcribes audio into structured text with timestamps.
+
+  Please analyze the audio and provide:
+  1. The complete transcript text
+  2. If possible, break it into segments with start and end timestamps (in seconds)
+  3. Detect the language used in the audio
+  4. Estimate the total duration of the audio
+
+  Return the result in the specified JSON schema format.
+`;

package/src/memory/client.ts

@@ -0,0 +1,158 @@
+import { getAiMemoryConfig } from './config';
+import type { AiMemoryConfig } from './types';
+
+type RequestOptions = {
+  timeout?: number;
+};
+
+type AddMemoryPayload = {
+  containerTag: string;
+  content: string;
+  customId: string;
+  embedding: number[];
+  metadata: Record<string, unknown>;
+};
+
+type SearchMemoriesPayload = {
+  containerTag: string;
+  embedding: number[];
+  filters?: unknown;
+  include?: unknown;
+  limit: number;
+  q: string;
+  searchMode?: 'hybrid';
+};
+
+type ListDocumentsPayload = {
+  containerTags: string[];
+  filters?: unknown;
+  includeContent: boolean;
+  limit: number;
+  order: 'asc' | 'desc';
+  sort: 'updatedAt';
+};
+
+type ForgetMemoryPayload = {
+  containerTag: string;
+  id: string;
+  reason: string;
+};
+
+let cachedClient: AiMemoryServiceClient | null = null;
+let cachedSignature: string | null = null;
+
+function configSignature(config: AiMemoryConfig) {
+  return [config.apiKey, config.baseUrl ?? ''].join('|');
+}
+
+function trimTrailingSlash(value: string) {
+  return value.replace(/\/+$/u, '');
+}
+
+export class AiMemoryServiceClient {
+  private readonly apiKey: string;
+  private readonly baseUrl: string;
+  private readonly timeoutMs: number;
+
+  constructor(config: AiMemoryConfig) {
+    this.apiKey = config.apiKey;
+    this.baseUrl = trimTrailingSlash(
+      config.baseUrl ?? 'http://supermemory:8787'
+    );
+    this.timeoutMs = config.timeoutMs;
+  }
+
+  async add(payload: AddMemoryPayload, options?: RequestOptions) {
+    return this.post<{ id: string; status: string }>(
+      '/v1/memories',
+      payload,
+      options
+    );
+  }
+
+  async searchMemories(
+    payload: SearchMemoriesPayload,
+    options?: RequestOptions
+  ) {
+    return this.post<{
+      results: Array<{
+        chunk?: string;
+        id: string;
+        memory?: string;
+        metadata?: Record<string, unknown> | null;
+        similarity?: number;
+        updatedAt?: string;
+      }>;
+    }>('/v1/search', payload, options);
+  }
+
+  async listDocuments(payload: ListDocumentsPayload, options?: RequestOptions) {
+    return this.post<{
+      memories: Array<{
+        content?: string | null;
+        id: string;
+        metadata?: unknown;
+        status: string;
+        summary?: string | null;
+        title?: string | null;
+        updatedAt: string;
+      }>;
+    }>('/v1/documents/list', payload, options);
+  }
+
+  async forgetMemory(payload: ForgetMemoryPayload, options?: RequestOptions) {
+    return this.post<{ forgotten: boolean; id: string }>(
+      '/v1/memories/forget',
+      payload,
+      options
+    );
+  }
+
+  private async post<T>(
+    path: string,
+    payload: unknown,
+    options?: RequestOptions
+  ): Promise<T> {
+    const controller = new AbortController();
+    const timeout = setTimeout(
+      () => controller.abort(),
+      options?.timeout ?? this.timeoutMs
+    );
+
+    try {
+      const response = await fetch(`${this.baseUrl}${path}`, {
+        body: JSON.stringify(payload),
+        headers: {
+          Authorization: `Bearer ${this.apiKey}`,
+          'Content-Type': 'application/json',
+        },
+        method: 'POST',
+        signal: controller.signal,
+      });
+
+      if (!response.ok) {
+        throw new Error(
+          `AI memory request failed with HTTP ${response.status}`
+        );
+      }
+
+      return (await response.json()) as T;
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+}
+
+export function getAiMemoryServiceClient(config = getAiMemoryConfig()) {
+  if (!config) return null;
+
+  const signature = configSignature(config);
+  if (!cachedClient || cachedSignature !== signature) {
+    cachedClient = new AiMemoryServiceClient(config);
+    cachedSignature = signature;
+  }
+
+  return cachedClient;
+}
+
+export const getSupermemoryClient = getAiMemoryServiceClient;