How ZaguanLabs Uses tstlai

// src/lib/translator.ts
import 'server-only';
import { Tstlai } from 'tstlai';

const instances = new Map<string, Tstlai>();

export function getTranslator(locale: string = 'en') {
  if (!instances.has(locale)) {
    instances.set(
      locale,
      new Tstlai({
        targetLang: locale,
        sourceLang: 'en',
        provider: {
          type: 'openai',
          apiKey: process.env.OPENAI_API_KEY,
          model: 'zaguanai/gemini-flash-latest',  // Google Gemini Flash - fast and efficient for translation
          baseUrl: 'https://api.zaguanai.com/v1',
        },
        cache: {
          type: process.env.REDIS_URL ? 'redis' : 'memory',
          connectionString: process.env.REDIS_URL,
          keyPrefix: 'zaguanlabs:',
        },
        // Keep brand names untranslated
        excludedTerms: [
          'Zaguan', 'ZaguanLabs', 'Zaguán AI', 
          'tstlai', 'chaTTY', 'RayLM', 'LuminaryChat'
        ],
        translationContext: 'Tech startup website for AI developer tools and SDKs',
      }),
    );
  }
  return instances.get(locale)!;
}

// src/proxy.ts
import { NextResponse } from 'next/server';
import type { NextRequest } from 'next/server';
import { match } from '@formatjs/intl-localematcher';
import Negotiator from 'negotiator';
import { isLanguageSupported, SHORT_CODE_DEFAULTS } from 'tstlai';

// Use tstlai's short codes for browser negotiation
const NEGOTIATION_LOCALES = Object.keys(SHORT_CODE_DEFAULTS);
export const DEFAULT_LOCALE = 'en';

function getLocale(request: NextRequest): string {
  const headers = { 
    'accept-language': request.headers.get('accept-language') || '' 
  };
  const languages = new Negotiator({ headers }).languages();
  return match(languages, NEGOTIATION_LOCALES, DEFAULT_LOCALE);
}

export function proxy(request: NextRequest) {
  const { pathname } = request.nextUrl;
  const segments = pathname.split('/');
  const potentialLocale = segments[1];
  
  // Validate locale using tstlai's language support
  if (potentialLocale && /^[a-z]{2}$/.test(potentialLocale)) {
    if (isLanguageSupported(potentialLocale)) {
      return; // Valid locale, continue
    }
    // Unsupported language - redirect to English
    segments[1] = 'en';
    return NextResponse.redirect(new URL(segments.join('/'), request.url));
  }

  // No locale in URL, detect from browser
  const locale = getLocale(request);
  return NextResponse.redirect(new URL(`/${locale}${pathname}`, request.url));
}

// src/app/[locale]/layout.tsx
import { AutoTranslate } from 'tstlai/next';
import { getTranslator } from '@/lib/translator';
import { generateSessionToken } from '@/lib/session-token';

interface LocaleLayoutProps {
  children: React.ReactNode;
  params: Promise<{ locale: string }>;
}

export default async function LocaleLayout({ 
  children, 
  params 
}: LocaleLayoutProps) {
  const { locale } = await params;
  const translator = getTranslator(locale);
  const dir = translator.getDir(); // 'ltr' or 'rtl'

  // Generate a unique session token for secure API access
  const sessionToken = locale !== 'en' ? generateSessionToken() : null;

  return (
    <div dir={dir} lang={locale}>
      {children}
      {/* AutoTranslate with dynamic, secure endpoints */}
      {locale !== 'en' && sessionToken && (
        <AutoTranslate 
          targetLang={locale} 
          stream={true}
          endpoint={`/api/${sessionToken}/translate`}
          streamEndpoint={`/api/${sessionToken}/stream`}
          streamBuffer={500}
        />
      )}
    </div>
  );
}

// src/app/api/[sessionToken]/stream/route.ts
import { createNextStreamingRouteHandler } from 'tstlai/next';
import { getTranslator } from '@/lib/translator';
import { validateSessionToken } from '@/lib/session-token';

interface RouteParams {
  params: Promise<{ sessionToken: string }>;
}

export const POST = async (req: Request, { params }: RouteParams) => {
  const { sessionToken } = await params;

  // Validate session token before processing
  if (!validateSessionToken(sessionToken)) {
    return new Response(JSON.stringify({ error: 'Invalid session' }), {
      status: 401,
      headers: { 'Content-Type': 'application/json' },
    });
  }

  const body = await req.json();
  const { targetLang } = body;
  
  const translator = getTranslator(targetLang || 'en');
  const handler = createNextStreamingRouteHandler(translator);
  
  return handler(new Request(req.url, {
    method: 'POST',
    headers: req.headers,
    body: JSON.stringify(body),
  }));
};