Gemma 197M: Chrome's On-Device Task Model and the Five APIs It Powers

async function summarize(text, {
  type   = 'key-points',
  format = 'plain-text',
  length = 'medium',
  onProgress,
} = {}) {
  if (!('Summarizer' in self)) throw new Error('Summarizer API not supported');

  const availability = await Summarizer.availability();
  if (availability === 'unavailable') throw new Error('Summarizer not available on this device');

  const summarizer = await Summarizer.create({
    type, format, length,
    outputLanguage: 'en',   // required: 'en' | 'es' | 'ja'
    monitor(m) {
      m.addEventListener('downloadprogress', (e) => {
        const pct = e.total ? Math.round((e.loaded / e.total) * 100) : 0;
        onProgress?.(pct);
      });
    },
  });

  // Check token budget — guard required: not exposed in all builds
  if (typeof summarizer.measureInputUsage === 'function') {
    try {
      const usage = await summarizer.measureInputUsage(text);
      if (usage > summarizer.inputQuota) {
        summarizer.destroy();
        throw new Error(`Input too long: ${usage} tokens, quota is ${summarizer.inputQuota}`);
      }
    } catch (e) {
      if (e.message?.includes('too long')) throw e;
      // TypeError: not implemented in this build — skip quota check
    }
  }

  let result = '';
  const stream = summarizer.summarizeStreaming(text);
  for await (const chunk of stream) {
    // defensive: older builds yield cumulative text; newer builds yield deltas
    if (chunk.startsWith(result)) result = chunk;
    else                          result += chunk;
  }

  summarizer.destroy();
  return result;
}

// Usage
const summary = await summarize(longArticleText, {
  type:   'key-points',
  format: 'markdown',
  length: 'short',
  onProgress: (pct) => console.log(`Model: ${pct}%`),
});

async function detectLanguage(text) {
  if (!('LanguageDetector' in self)) return null;

  const availability = await LanguageDetector.availability();
  if (availability === 'unavailable') return null;

  const detector = await LanguageDetector.create();
  const results = await detector.detect(text);
  detector.destroy();

  // [ { detectedLanguage: 'it', confidence: 0.97 },
  //   { detectedLanguage: 'la', confidence: 0.02 }, ... ]
  return {
    primary:     results[0]?.detectedLanguage ?? 'en',
    confidence:  results[0]?.confidence ?? 0,
    all:         results,
  };
}

// Route a support ticket to the right team by language
async function routeTicket(ticketBody) {
  const { primary, confidence } = (await detectLanguage(ticketBody)) ?? {};
  if (confidence > 0.85) {
    return ROUTING_MAP[primary] ?? 'default-queue';
  }
  return 'default-queue'; // low-confidence fallback
}

async function translate(text, { from, to }) {
  if (!('Translator' in self)) throw new Error('Translator API not supported');

  // Check pair-specific availability before creating the instance
  const availability = await Translator.availability({
    sourceLanguage: from,
    targetLanguage: to,
  });
  if (availability === 'unavailable') {
    throw new Error(`Translation pair ${from}→${to} not available on this device`);
  }

  const translator = await Translator.create({
    sourceLanguage: from,
    targetLanguage: to,
    monitor(m) {
      m.addEventListener('downloadprogress', (e) => {
        console.log(`Language pair: ${Math.round(e.loaded / e.total * 100)}%`);
      });
    },
  });

  const result = await translator.translate(text);
  translator.destroy();
  return result;
}

// Translate user review to English for downstream processing
const english = await translate('Produit excellent, livraison rapide', {
  from: 'fr',
  to:   'en',
});

async function summarizeAnyLanguage(text, {
  summaryType   = 'key-points',
  summaryLength = 'short',
  targetLang    = 'en',
} = {}) {

  // Step 1: Detect source language
  const detection = await detectLanguage(text);
  const sourceLang = detection?.primary ?? targetLang;

  // Step 2: Translate only if needed
  let processText = text;
  if (sourceLang !== targetLang && detection?.confidence > 0.80) {
    try {
      processText = await translate(text, { from: sourceLang, to: targetLang });
    } catch {
      // Pair not available — summarize in original language
    }
  }

  // Step 3: Summarize
  return summarize(processText, { type: summaryType, length: summaryLength });
}

// Process a French contract brief into English key points
const keyPoints = await summarizeAnyLanguage(frenchContractText, {
  summaryType:   'key-points',
  summaryLength: 'medium',
  targetLang:    'en',
});