Chrome Nano AI Errors: Complete Troubleshooting Guide

[PLACEHOLDER: Troubleshooting Decision Flowchart]

Start
  ↓
Is LanguageModel available? (window.LanguageModel exists)
  ├─ No → Error: API Not Available → Solution: Update Chrome or enable AI features
  └─ Yes
      ↓
Check availability status (await LanguageModel.availability())
  ├─ "unavailable" → Error: Device unsupported → Solution: Use cloud fallback
  ├─ "downloadable" → Error: Model not downloaded → Solution: Trigger download
  ├─ "downloading" → Info: Download in progress → Solution: Wait or show progress
  └─ "readily-available"
      ↓
Create session (await LanguageModel.create())
  ├─ NotAllowedError → Error: No user gesture → Solution: Call in user event handler
  ├─ Timeout/Failure → Error: Resource issue → Solution: Retry with backoff
  └─ Success
      ↓
Execute prompt (await session.prompt())
  ├─ Execution error → Check prompt structure and length
  └─ Success → Continue operation

// Console error:
ReferenceError: LanguageModel is not defined

// Or runtime check fails:
if (typeof window !== "undefined" && "LanguageModel" in window) {
  // This block never executes
}

// Step 1: Check if running in browser context
if (typeof window === "undefined") {
  console.error("Not running in browser context");
}

// Step 2: Check Chrome version
const chromeVersion = navigator.userAgent.match(/Chrome\/(\d+)/)?.[1];
if (chromeVersion && parseInt(chromeVersion) < 138) {
  console.error(`Chrome version ${chromeVersion} detected. Need 138+`);
}

// Step 3: Check API availability
if (!("LanguageModel" in window)) {
  console.error("LanguageModel API not available");
  console.log("Check chrome://settings/ai to enable Built-in AI");
}

# Check current version
chrome://version

# Update to Chrome 138+
# Navigate to: chrome://settings/help
# Chrome will auto-update to latest version

# Navigate to: chrome://settings/ai
# Ensure "Help me write" and "AI features" are enabled
# Restart Chrome after enabling

class NanoAiService {
  static isAvailable(): boolean {
    return typeof window !== "undefined" && "LanguageModel" in window;
  }

  async initialize() {
    if (!NanoAiService.isAvailable()) {
      throw new Error(
        "Chrome Nano AI not available. " +
        "Update to Chrome 138+ and enable AI features at chrome://settings/ai"
      );
    }

    // Proceed with initialization
    const availability = await window.LanguageModel.availability();
    return availability;
  }
}

class HybridAiService {
  async prompt(text: string): Promise<string> {
    // Try on-device AI first
    if (NanoAiService.isAvailable()) {
      try {
        return await this.nanoAi.prompt(text);
      } catch (error) {
        console.warn("On-device AI failed, falling back to cloud", error);
      }
    }

    // Fallback to cloud API
    return await this.cloudAi.prompt(text);
  }
}

// Attempting to create session outside user gesture
async function initializeAi() {
  const session = await LanguageModel.create();
  // Error: NotAllowedError: Failed to execute 'create' on 'LanguageModel'
}

// Called from non-user-initiated context
setTimeout(initializeAi, 1000); // Will fail

// Detect when you're in user gesture context
function hasUserGesture(): boolean {
  try {
    // Attempt an operation that requires user gesture
    const audio = new Audio();
    audio.play(); // Will throw if no gesture
    audio.pause();
    return true;
  } catch {
    return false;
  }
}

// Check during session creation
async function createSessionWithCheck() {
  console.log("Has user gesture:", hasUserGesture());

  try {
    const session = await LanguageModel.create();
    console.log("Session created successfully");
    return session;
  } catch (error) {
    if (error.name === "NotAllowedError") {
      console.error("NotAllowedError - user gesture required");
    }
    throw error;
  }
}

// ❌ INCORRECT: Gesture context lost after await
button.addEventListener('click', async () => {
  const data = await fetchSomeData(); // Async operation
  const session = await LanguageModel.create(); // NotAllowedError!
});

// ✅ CORRECT: Create session BEFORE async operations
button.addEventListener('click', async () => {
  const session = await LanguageModel.create(); // In gesture context
  const data = await fetchSomeData(); // Async OK after session created
  await session.prompt(`Process: ${data}`);
});

class NanoAiService {
  private session: LanguageModelSession | null = null;

  async ensureSession(): Promise<LanguageModelSession> {
    if (this.session) {
      return this.session;
    }

    // Must be called in user gesture context first time
    this.session = await LanguageModel.create();
    return this.session;
  }

  async prompt(text: string): Promise<string> {
    const session = await this.ensureSession();
    return await session.prompt(text);
  }
}

// Initialize on first user interaction
button.addEventListener('click', async () => {
  await aiService.ensureSession(); // Creates session if needed
  // Subsequent calls can use existing session
  const result = await aiService.prompt("Hello");
});

async function initializeWithUserPrompt() {
  const availability = await LanguageModel.availability();

  if (availability === "downloadable" || availability === "downloading") {
    // Show UI to prompt user action
    showNotification({
      title: "AI Features Need Setup",
      message: "Click to enable on-device AI features",
      action: async () => {
        // This click provides the user gesture
        try {
          const session = await LanguageModel.create();
          console.log("AI enabled successfully");
          return session;
        } catch (error) {
          console.error("Failed to enable AI", error);
        }
      }
    });
  }
}

async function safeSessionCreation() {
  // Check availability before attempting creation
  const availability = await LanguageModel.availability();

  if (availability === "readily-available") {
    // Safe to create without user gesture
    return await LanguageModel.create();
  }

  // Requires user gesture - inform user
  throw new Error(
    `Model not ready (${availability}). ` +
    "User interaction required to initialize AI features."
  );
}

// Availability check shows:
const availability = await LanguageModel.availability();
// Returns: "downloadable" or "downloading"

// User can't use AI features yet
const session = await LanguageModel.create();
// May hang, timeout, or throw NotAllowedError

async function diagnoseDownloadIssues() {
  const availability = await LanguageModel.availability();
  console.log("Model availability:", availability);

  // Check storage quota
  if ('storage' in navigator && 'estimate' in navigator.storage) {
    const estimate = await navigator.storage.estimate();
    const availableMB = ((estimate.quota - estimate.usage) / 1024 / 1024).toFixed(2);
    console.log(`Available storage: ${availableMB}MB`);

    if (estimate.quota - estimate.usage < 500 * 1024 * 1024) {
      console.warn("Low disk space may prevent model download");
    }
  }

  // Check network status
  if ('connection' in navigator) {
    console.log("Connection type:", navigator.connection?.effectiveType);
    console.log("Online status:", navigator.onLine);
  }
}

async function createSessionWithProgress() {
  const availability = await LanguageModel.availability();

  if (availability === "downloadable") {
    console.log("Model needs download - requires user gesture");
  }

  const session = await LanguageModel.create({
    monitor(monitor) {
      monitor.addEventListener("downloadprogress", (e) => {
        const percent = (e.loaded / e.total * 100).toFixed(1);
        console.log(`Download progress: ${percent}%`);

        // Update UI with progress
        updateProgressBar(percent);
      });
    }
  });

  return session;
}

class DownloadManager {
  private downloadState: {
    status: 'not_started' | 'in_progress' | 'completed' | 'failed';
    progress: number;
    error?: string;
  } = { status: 'not_started', progress: 0 };

  async initiateDownload(): Promise<LanguageModelSession> {
    this.downloadState.status = 'in_progress';

    try {
      const session = await LanguageModel.create({
        monitor: (monitor) => {
          monitor.addEventListener("downloadprogress", (e) => {
            this.downloadState.progress = (e.loaded / e.total * 100);
            this.notifyListeners();
          });
        }
      });

      this.downloadState.status = 'completed';
      this.downloadState.progress = 100;
      return session;

    } catch (error) {
      this.downloadState.status = 'failed';
      this.downloadState.error = error.message;
      throw error;
    }
  }

  getDownloadState() {
    return this.downloadState;
  }
}

async function initializeWithUI() {
  const availability = await LanguageModel.availability();

  switch (availability) {
    case "readily-available":
      return await LanguageModel.create();

    case "downloadable":
      return await showDownloadPrompt({
        title: "Enable On-Device AI",
        message: "Download AI model (~250MB) for offline use?",
        onConfirm: async () => {
          showProgressModal();
          return await LanguageModel.create({
            monitor: (m) => {
              m.addEventListener("downloadprogress", (e) => {
                updateProgressModal(e.loaded / e.total * 100);
              });
            }
          });
        }
      });

    case "downloading":
      return await showWaitingUI({
        message: "AI model downloading... Please wait."
      });

    case "unavailable":
      throw new Error("On-device AI not supported on this device");
  }
}

async function robustDownload(maxRetries = 3): Promise<LanguageModelSession> {
  for (let attempt = 1; attempt <= maxRetries; attempt++) {
    try {
      console.log(`Download attempt ${attempt}/${maxRetries}`);

      const session = await LanguageModel.create({
        monitor: (monitor) => {
          monitor.addEventListener("downloadprogress", (e) => {
            console.log(`Progress: ${(e.loaded/e.total*100).toFixed(1)}%`);
          });
        }
      });

      console.log("Download completed successfully");
      return session;

    } catch (error) {
      console.error(`Download attempt ${attempt} failed:`, error);

      if (attempt === maxRetries) {
        throw new Error(
          `Failed to download AI model after ${maxRetries} attempts. ` +
          "Check your internet connection and available storage space."
        );
      }

      // Wait before retry (exponential backoff)
      await new Promise(resolve => setTimeout(resolve, 1000 * attempt));
    }
  }
}

// Availability check returns unexpected or changing values
const availability = await LanguageModel.availability();
console.log(availability); // May be "unavailable", "downloading", etc.

// Or availability changes during operation
const initial = await LanguageModel.availability(); // "readily-available"
// ... some time passes ...
const later = await LanguageModel.availability(); // "downloading" (update in progress)

class AvailabilityManager {
  async checkAndHandle(): Promise<'ready' | 'downloading' | 'unavailable'> {
    const availability = await LanguageModel.availability();

    switch (availability) {
      case "readily-available":
        console.log("✓ AI model ready");
        return 'ready';

      case "downloadable":
        console.log("⚠ Model needs download");
        await this.promptUserForDownload();
        return 'downloading';

      case "downloading":
        console.log("⏳ Model download in progress");
        await this.waitForDownload();
        return await this.checkAndHandle(); // Recheck after download

      case "unavailable":
        console.log("✗ On-device AI not supported");
        return 'unavailable';

      default:
        console.warn("Unknown availability status:", availability);
        return 'unavailable';
    }
  }

  private async waitForDownload(): Promise<void> {
    // Poll until download completes or fails
    const maxWait = 300000; // 5 minutes
    const startTime = Date.now();

    while (Date.now() - startTime < maxWait) {
      await new Promise(resolve => setTimeout(resolve, 2000));

      const status = await LanguageModel.availability();
      if (status === "readily-available") {
        return;
      }
      if (status === "unavailable") {
        throw new Error("Download failed - model became unavailable");
      }
    }

    throw new Error("Download timeout - exceeded maximum wait time");
  }
}

class CachedAvailability {
  private cache: {
    status: string;
    timestamp: number;
  } | null = null;

  private readonly CACHE_DURATION = 60000; // 1 minute

  async getAvailability(forceRefresh = false): Promise<string> {
    // Return cached value if fresh
    if (!forceRefresh && this.cache) {
      const age = Date.now() - this.cache.timestamp;
      if (age < this.CACHE_DURATION) {
        return this.cache.status;
      }
    }

    // Fetch fresh status
    const status = await LanguageModel.availability();
    this.cache = {
      status,
      timestamp: Date.now()
    };

    return status;
  }

  invalidate() {
    this.cache = null;
  }
}

class AdaptiveAiService {
  async prompt(text: string): Promise<string> {
    const availability = await LanguageModel.availability();

    if (availability === "readily-available") {
      // Use on-device AI
      return await this.promptWithNanoAi(text);
    }

    if (availability === "downloadable" || availability === "downloading") {
      // Offer choice: wait for download or use cloud
      return await this.promptUserChoice({
        local: () => this.waitAndUseNanoAi(text),
        cloud: () => this.promptWithCloudAi(text)
      });
    }

    // Fallback to cloud for "unavailable"
    return await this.promptWithCloudAi(text);
  }
}

// Session creation fails with various errors
try {
  const session = await LanguageModel.create();
} catch (error) {
  // Possible errors:
  // - Timeout
  // - Resource unavailable
  // - Invalid parameters
  // - System busy
}

async function diagnoseSessionCreation() {
  console.log("Diagnosing session creation...");

  // Check availability
  const availability = await LanguageModel.availability();
  console.log("Availability:", availability);

  // Get default parameters
  try {
    const params = await LanguageModel.params();
    console.log("Default params:", params);
  } catch (error) {
    console.error("Failed to get default params:", error);
  }

  // Attempt session creation with logging
  const startTime = Date.now();
  try {
    const session = await LanguageModel.create({
      temperature: 0.7,
      topK: 5
    });
    console.log(`Session created in ${Date.now() - startTime}ms`);
    return session;
  } catch (error) {
    console.error(`Session creation failed after ${Date.now() - startTime}ms:`, error);
    throw error;
  }
}

async function createSessionWithDefaults() {
  try {
    // Get default parameters first
    const defaultParams = await LanguageModel.params();

    const session = await LanguageModel.create({
      temperature: defaultParams.defaultTemperature ?? 0.7,
      topK: defaultParams.defaultTopK ?? 5,
      initialPrompts: []
    });

    return session;

  } catch (error) {
    console.error("Failed to create session with defaults:", error);

    // Retry with minimal config
    return await LanguageModel.create();
  }
}

class SessionPool {
  private sessions: Set<LanguageModelSession> = new Set();
  private readonly maxSessions = 3;

  async getSession(): Promise<LanguageModelSession> {
    // Reuse existing session if available
    if (this.sessions.size < this.maxSessions) {
      const session = await LanguageModel.create();
      this.sessions.add(session);
      return session;
    }

    // Return existing session (will be reused)
    return Array.from(this.sessions)[0];
  }

  releaseSession(session: LanguageModelSession) {
    session.destroy();
    this.sessions.delete(session);
  }

  cleanup() {
    this.sessions.forEach(s => s.destroy());
    this.sessions.clear();
  }
}

async function createSessionWithRetry(
  maxRetries = 3,
  baseDelay = 1000
): Promise<LanguageModelSession> {

  for (let attempt = 1; attempt <= maxRetries; attempt++) {
    try {
      const session = await LanguageModel.create();
      return session;

    } catch (error) {
      console.warn(`Session creation attempt ${attempt} failed:`, error);

      if (attempt === maxRetries) {
        throw new Error(
          `Failed to create session after ${maxRetries} attempts: ${error.message}`
        );
      }

      // Exponential backoff
      const delay = baseDelay * Math.pow(2, attempt - 1);
      await new Promise(resolve => setTimeout(resolve, delay));
    }
  }
}

async function createSessionWithValidation(customParams?: {
  temperature?: number;
  topK?: number;
}) {
  // Get valid ranges
  const defaults = await LanguageModel.params();

  // Validate temperature
  const temperature = customParams?.temperature ?? defaults.defaultTemperature ?? 0.7;
  if (temperature < 0 || temperature > 2) {
    throw new Error(`Invalid temperature: ${temperature}. Must be between 0 and 2`);
  }

  // Validate topK
  const topK = customParams?.topK ?? defaults.defaultTopK ?? 5;
  if (topK < 1 || topK > 100) {
    throw new Error(`Invalid topK: ${topK}. Must be between 1 and 100`);
  }

  return await LanguageModel.create({
    temperature,
    topK,
    initialPrompts: []
  });
}

const session = await LanguageModel.create();

try {
  const response = await session.prompt("Your prompt here");
} catch (error) {
  // Possible errors:
  // - Prompt too long
  // - Invalid characters or encoding
  // - Session destroyed
  // - Timeout
}

class PromptValidator {
  private readonly MAX_TOKENS = 8000; // Approximate
  private readonly CHARS_PER_TOKEN = 4; // Rough estimate

  validatePrompt(prompt: string): { valid: boolean; reason?: string } {
    // Check length
    const estimatedTokens = prompt.length / this.CHARS_PER_TOKEN;
    if (estimatedTokens > this.MAX_TOKENS) {
      return {
        valid: false,
        reason: `Prompt too long (~${Math.round(estimatedTokens)} tokens, max ${this.MAX_TOKENS})`
      };
    }

    // Check for empty prompt
    if (!prompt.trim()) {
      return {
        valid: false,
        reason: "Prompt cannot be empty"
      };
    }

    return { valid: true };
  }

  async safePrompt(
    session: LanguageModelSession,
    prompt: string
  ): Promise<string> {
    const validation = this.validatePrompt(prompt);

    if (!validation.valid) {
      throw new Error(`Invalid prompt: ${validation.reason}`);
    }

    return await session.prompt(prompt);
  }
}

async function promptWithLongContent(
  session: LanguageModelSession,
  longContent: string,
  maxChunkSize = 30000 // characters
): Promise<string> {

  if (longContent.length <= maxChunkSize) {
    return await session.prompt(longContent);
  }

  // Split into chunks
  const chunks: string[] = [];
  for (let i = 0; i < longContent.length; i += maxChunkSize) {
    chunks.push(longContent.slice(i, i + maxChunkSize));
  }

  console.log(`Processing ${chunks.length} chunks...`);

  // Process each chunk
  const results: string[] = [];
  for (let i = 0; i < chunks.length; i++) {
    console.log(`Processing chunk ${i + 1}/${chunks.length}`);
    const result = await session.prompt(
      `Summarize this part (${i + 1}/${chunks.length}):\n${chunks[i]}`
    );
    results.push(result);
  }

  // Combine results
  if (results.length === 1) {
    return results[0];
  }

  return await session.prompt(
    `Combine these summaries into one:\n${results.join('\n\n')}`
  );
}

async function promptWithTimeout(
  session: LanguageModelSession,
  prompt: string,
  timeoutMs = 30000
): Promise<string> {

  return await Promise.race([
    session.prompt(prompt),
    new Promise<never>((_, reject) =>
      setTimeout(
        () => reject(new Error(`Prompt execution timeout after ${timeoutMs}ms`)),
        timeoutMs
      )
    )
  ]);
}

// With abort signal
async function promptWithAbort(
  session: LanguageModelSession,
  prompt: string,
  signal?: AbortSignal
): Promise<string> {

  if (signal?.aborted) {
    throw new Error("Operation aborted");
  }

  // Start prompt execution
  const promptPromise = session.prompt(prompt);

  // Listen for abort
  if (signal) {
    const abortPromise = new Promise<never>((_, reject) => {
      signal.addEventListener('abort', () => {
        reject(new Error("Operation aborted by user"));
      });
    });

    return await Promise.race([promptPromise, abortPromise]);
  }

  return await promptPromise;
}

class ManagedSession {
  private session: LanguageModelSession | null = null;
  private isValid = false;

  async initialize() {
    this.session = await LanguageModel.create();
    this.isValid = true;
  }

  async prompt(text: string): Promise<string> {
    if (!this.isValid || !this.session) {
      throw new Error("Session not initialized or destroyed");
    }

    try {
      return await this.session.prompt(text);
    } catch (error) {
      console.error("Prompt execution failed:", error);

      // Check if session needs recreation
      if (error.message.includes("session") || error.message.includes("destroyed")) {
        console.log("Attempting to recreate session...");
        await this.initialize();
        return await this.session!.prompt(text);
      }

      throw error;
    }
  }

  destroy() {
    if (this.session) {
      this.session.destroy();
      this.session = null;
      this.isValid = false;
    }
  }
}

try {
  for await (const chunk of session.promptStreaming("Your prompt")) {
    console.log(chunk);
    // Streaming may:
    // - Stop prematurely
    // - Throw errors mid-stream
    // - Provide incomplete data
  }
} catch (error) {
  console.error("Streaming failed:", error);
}

async function* robustStreaming(
  session: LanguageModelSession,
  prompt: string
): AsyncIterable<string> {
  let accumulatedContent = "";
  let chunkCount = 0;

  try {
    for await (const chunk of session.promptStreaming(prompt)) {
      chunkCount++;
      accumulatedContent += chunk;
      yield accumulatedContent;
    }

    console.log(`Streaming completed: ${chunkCount} chunks received`);

  } catch (error) {
    console.error("Streaming interrupted:", error);

    // Return accumulated content even if stream fails
    if (accumulatedContent) {
      console.log("Returning partial result");
      yield accumulatedContent;
    }

    throw error;
  }
}

async function* streamingWithAbort(
  session: LanguageModelSession,
  prompt: string,
  signal?: AbortSignal
): AsyncIterable<string> {

  if (signal?.aborted) {
    throw new Error("Operation aborted before start");
  }

  let accumulatedContent = "";

  try {
    for await (const chunk of session.promptStreaming(prompt)) {
      // Check abort signal
      if (signal?.aborted) {
        console.log("Streaming aborted by user");
        throw new Error("Streaming aborted");
      }

      accumulatedContent += chunk;
      yield accumulatedContent;
    }
  } catch (error) {
    // Cleanup on error
    console.error("Streaming error:", error);
    throw error;
  }
}

// Usage
const abortController = new AbortController();

// Cancel button handler
cancelButton.addEventListener('click', () => {
  abortController.abort();
});

// Use streaming
try {
  for await (const content of streamingWithAbort(
    session,
    "Your prompt",
    abortController.signal
  )) {
    updateUI(content);
  }
} catch (error) {
  if (error.message.includes("aborted")) {
    console.log("User cancelled operation");
  }
}

async function* streamingWithTimeout(
  session: LanguageModelSession,
  prompt: string,
  chunkTimeoutMs = 5000
): AsyncIterable<string> {

  let accumulatedContent = "";

  const iterator = session.promptStreaming(prompt)[Symbol.asyncIterator]();

  while (true) {
    // Race between next chunk and timeout
    const result = await Promise.race([
      iterator.next(),
      new Promise<{ done: true, value: undefined }>((resolve) =>
        setTimeout(() => resolve({ done: true, value: undefined }), chunkTimeoutMs)
      )
    ]);

    if (result.done) {
      break;
    }

    accumulatedContent += result.value;
    yield accumulatedContent;
  }
}

class AdaptivePrompting {
  async executeWithFallback(
    session: LanguageModelSession,
    prompt: string,
    preferStreaming = true
  ): Promise<string> {

    if (preferStreaming) {
      try {
        // Try streaming first
        let result = "";
        for await (const chunk of session.promptStreaming(prompt)) {
          result = chunk;
        }
        return result;

      } catch (error) {
        console.warn("Streaming failed, falling back to non-streaming:", error);
      }
    }

    // Fallback to regular prompt
    return await session.prompt(prompt);
  }
}

// Multiple sessions or operations causing:
// - Out of memory errors
// - Browser tab crashes
// - Slow performance
// - Session creation failures

class ResourceMonitor {
  private sessions = new Set<LanguageModelSession>();

  trackSession(session: LanguageModelSession) {
    this.sessions.add(session);
    console.log(`Active sessions: ${this.sessions.size}`);
  }

  releaseSession(session: LanguageModelSession) {
    session.destroy();
    this.sessions.delete(session);
    console.log(`Active sessions: ${this.sessions.size}`);
  }

  async checkMemoryUsage() {
    if ('memory' in performance) {
      const memory = (performance as any).memory;
      console.log('Memory usage:', {
        used: `${(memory.usedJSHeapSize / 1024 / 1024).toFixed(2)}MB`,
        total: `${(memory.totalJSHeapSize / 1024 / 1024).toFixed(2)}MB`,
        limit: `${(memory.jsHeapSizeLimit / 1024 / 1024).toFixed(2)}MB`
      });
    }
  }

  cleanup() {
    console.log(`Cleaning up ${this.sessions.size} sessions`);
    this.sessions.forEach(s => s.destroy());
    this.sessions.clear();
  }
}

class SessionManager {
  private session: LanguageModelSession | null = null;
  private operationCount = 0;
  private readonly MAX_OPERATIONS = 100; // Recreate after N operations

  async getSession(): Promise<LanguageModelSession> {
    // Recreate session periodically to prevent memory buildup
    if (this.session && this.operationCount >= this.MAX_OPERATIONS) {
      console.log("Recreating session after max operations");
      this.destroy();
    }

    if (!this.session) {
      this.session = await LanguageModel.create();
      this.operationCount = 0;
    }

    return this.session;
  }

  async execute(prompt: string): Promise<string> {
    const session = await this.getSession();
    this.operationCount++;
    return await session.prompt(prompt);
  }

  destroy() {
    if (this.session) {
      this.session.destroy();
      this.session = null;
      this.operationCount = 0;
    }
  }
}

class RateLimitedExecutor {
  private queue: Array<() => Promise<void>> = [];
  private activeCount = 0;
  private readonly maxConcurrent = 2;

  async execute<T>(operation: () => Promise<T>): Promise<T> {
    // Wait if at capacity
    while (this.activeCount >= this.maxConcurrent) {
      await new Promise(resolve => setTimeout(resolve, 100));
    }

    this.activeCount++;

    try {
      return await operation();
    } finally {
      this.activeCount--;
    }
  }
}

// Usage
const executor = new RateLimitedExecutor();

// These will execute max 2 at a time
await Promise.all([
  executor.execute(() => processTask1()),
  executor.execute(() => processTask2()),
  executor.execute(() => processTask3()),
  executor.execute(() => processTask4())
]);

async function processLargeDataset(
  items: string[],
  batchSize = 10
): Promise<string[]> {
  const results: string[] = [];

  // Process in batches to limit memory usage
  for (let i = 0; i < items.length; i += batchSize) {
    console.log(`Processing batch ${Math.floor(i / batchSize) + 1}`);

    const batch = items.slice(i, i + batchSize);

    // Create session for batch
    const session = await LanguageModel.create();

    try {
      // Process batch items
      for (const item of batch) {
        const result = await session.prompt(`Process: ${item}`);
        results.push(result);
      }
    } finally {
      // Cleanup immediately after batch
      session.destroy();

      // Allow garbage collection
      await new Promise(resolve => setTimeout(resolve, 100));
    }
  }

  return results;
}

class AutoCleanupManager {
  private sessions = new Set<LanguageModelSession>();

  constructor() {
    // Cleanup on page unload
    window.addEventListener('beforeunload', () => {
      this.cleanup();
    });

    // Cleanup on navigation
    if ('navigation' in window) {
      (window as any).navigation.addEventListener('navigate', () => {
        this.cleanup();
      });
    }
  }

  registerSession(session: LanguageModelSession) {
    this.sessions.add(session);
  }

  cleanup() {
    console.log(`Cleaning up ${this.sessions.size} sessions`);
    this.sessions.forEach(s => {
      try {
        s.destroy();
      } catch (error) {
        console.error("Error destroying session:", error);
      }
    });
    this.sessions.clear();
  }
}

class DebugLogger {
  private enabled = false;

  enable() {
    this.enabled = true;
  }

  log(category: string, message: string, data?: any) {
    if (!this.enabled) return;

    console.log(`[${category}] ${message}`, data || '');
  }

  async createDebugSession() {
    this.log('Session', 'Checking availability...');
    const availability = await LanguageModel.availability();
    this.log('Session', 'Availability result', availability);

    this.log('Session', 'Getting default params...');
    const params = await LanguageModel.params();
    this.log('Session', 'Default params', params);

    this.log('Session', 'Creating session...');
    const startTime = Date.now();

    try {
      const session = await LanguageModel.create({
        monitor: (monitor) => {
          monitor.addEventListener('downloadprogress', (e) => {
            this.log('Download', 'Progress', {
              loaded: e.loaded,
              total: e.total,
              percent: (e.loaded / e.total * 100).toFixed(1)
            });
          });
        }
      });

      this.log('Session', 'Created successfully', {
        duration: Date.now() - startTime
      });

      return session;
    } catch (error) {
      this.log('Session', 'Creation failed', {
        error: error.message,
        duration: Date.now() - startTime
      });
      throw error;
    }
  }
}

// Expose debug interface to console
(window as any).__nanoAiDebug = {
  async checkStatus() {
    console.group('Chrome Nano AI Status');

    console.log('API Available:', 'LanguageModel' in window);

    if ('LanguageModel' in window) {
      const availability = await LanguageModel.availability();
      console.log('Availability:', availability);

      const params = await LanguageModel.params();
      console.log('Default Params:', params);
    }

    if ('memory' in performance) {
      const memory = (performance as any).memory;
      console.log('Memory Usage:', {
        used: `${(memory.usedJSHeapSize / 1024 / 1024).toFixed(2)}MB`,
        limit: `${(memory.jsHeapSizeLimit / 1024 / 1024).toFixed(2)}MB`
      });
    }

    console.groupEnd();
  },

  async testSession() {
    console.log('Creating test session...');
    const session = await LanguageModel.create();

    console.log('Executing test prompt...');
    const response = await session.prompt('Say "test successful"');

    console.log('Response:', response);

    session.destroy();
    console.log('Test completed successfully');
  }
};

// Usage in console:
// __nanoAiDebug.checkStatus()
// __nanoAiDebug.testSession()

class PerformanceProfiler {
  private metrics: Map<string, number[]> = new Map();

  async profileOperation<T>(
    name: string,
    operation: () => Promise<T>
  ): Promise<T> {
    const startTime = performance.now();

    try {
      const result = await operation();
      const duration = performance.now() - startTime;

      this.recordMetric(name, duration);
      console.log(`${name}: ${duration.toFixed(2)}ms`);

      return result;
    } catch (error) {
      const duration = performance.now() - startTime;
      console.error(`${name} failed after ${duration.toFixed(2)}ms:`, error);
      throw error;
    }
  }

  private recordMetric(name: string, duration: number) {
    if (!this.metrics.has(name)) {
      this.metrics.set(name, []);
    }
    this.metrics.get(name)!.push(duration);
  }

  getStats(name: string) {
    const values = this.metrics.get(name) || [];
    if (values.length === 0) return null;

    const sorted = [...values].sort((a, b) => a - b);
    const sum = values.reduce((a, b) => a + b, 0);

    return {
      count: values.length,
      avg: sum / values.length,
      min: sorted[0],
      max: sorted[sorted.length - 1],
      median: sorted[Math.floor(sorted.length / 2)]
    };
  }

  printReport() {
    console.group('Performance Report');

    for (const [name, _] of this.metrics) {
      const stats = this.getStats(name);
      console.log(`${name}:`, stats);
    }

    console.groupEnd();
  }
}

// Usage
const profiler = new PerformanceProfiler();

await profiler.profileOperation('Session Creation', async () => {
  return await LanguageModel.create();
});

await profiler.profileOperation('Prompt Execution', async () => {
  return await session.prompt('Test');
});

profiler.printReport();

class RobustNanoAiService {
  private session: LanguageModelSession | null = null;

  async initialize(): Promise<boolean> {
    try {
      // Check API availability
      if (!('LanguageModel' in window)) {
        console.error('LanguageModel API not available');
        return false;
      }

      // Check model availability
      const availability = await LanguageModel.availability();
      if (availability === 'unavailable') {
        console.error('On-device AI not supported');
        return false;
      }

      if (availability !== 'readily-available') {
        console.warn(`Model status: ${availability}`);
        return false;
      }

      // Create session
      this.session = await LanguageModel.create();
      return true;

    } catch (error) {
      console.error('Failed to initialize Nano AI:', error);
      return false;
    }
  }

  async prompt(text: string): Promise<string | null> {
    try {
      if (!this.session) {
        const initialized = await this.initialize();
        if (!initialized) {
          return null;
        }
      }

      return await this.session!.prompt(text);

    } catch (error) {
      console.error('Prompt execution failed:', error);

      // Try to recover by recreating session
      try {
        this.destroy();
        await this.initialize();
        return await this.session!.prompt(text);
      } catch (retryError) {
        console.error('Recovery failed:', retryError);
        return null;
      }
    }
  }

  destroy() {
    if (this.session) {
      this.session.destroy();
      this.session = null;
    }
  }
}

function getUserFriendlyError(error: Error): string {
  const errorMap: Record<string, string> = {
    'LanguageModel is not defined':
      'Your browser doesn\'t support on-device AI. Please update to Chrome 138+ and enable AI features in chrome://settings/ai',

    'NotAllowedError':
      'AI features need to be activated. Please click a button or interact with the page first.',

    'availability: unavailable':
      'Your device doesn\'t support on-device AI. Try using cloud-based AI instead.',

    'availability: downloadable':
      'AI model needs to be downloaded. Click to download (~250MB).',

    'availability: downloading':
      'AI model is downloading. This may take a few minutes.',

    'Session creation failed':
      'Failed to start AI session. Please try again or reload the page.',

    'Prompt too long':
      'Your request is too long. Please try breaking it into smaller parts.',

    'Out of memory':
      'Your device is running low on memory. Please close some tabs and try again.'
  };

  // Find matching error
  for (const [key, message] of Object.entries(errorMap)) {
    if (error.message.includes(key) || error.name === key) {
      return message;
    }
  }

  return 'An unexpected error occurred. Please try again.';
}

// Usage
try {
  await aiService.prompt("Your prompt");
} catch (error) {
  const userMessage = getUserFriendlyError(error);
  showNotification(userMessage);
}

class AiTelemetry {
  private events: Array<{
    type: string;
    timestamp: number;
    data: any;
  }> = [];

  recordEvent(type: string, data?: any) {
    this.events.push({
      type,
      timestamp: Date.now(),
      data
    });
  }

  async trackSession() {
    this.recordEvent('session_start');

    try {
      const availability = await LanguageModel.availability();
      this.recordEvent('availability_check', { availability });

      const session = await LanguageModel.create();
      this.recordEvent('session_created');

      return session;

    } catch (error) {
      this.recordEvent('session_failed', {
        error: error.message,
        name: error.name
      });
      throw error;
    }
  }

  async trackPrompt(session: LanguageModelSession, prompt: string) {
    const startTime = Date.now();
    this.recordEvent('prompt_start', {
      promptLength: prompt.length
    });

    try {
      const response = await session.prompt(prompt);
      this.recordEvent('prompt_success', {
        duration: Date.now() - startTime,
        responseLength: response.length
      });
      return response;

    } catch (error) {
      this.recordEvent('prompt_failed', {
        duration: Date.now() - startTime,
        error: error.message
      });
      throw error;
    }
  }

  getReport() {
    const sessionAttempts = this.events.filter(e =>
      e.type === 'session_start'
    ).length;

    const sessionSuccesses = this.events.filter(e =>
      e.type === 'session_created'
    ).length;

    const promptAttempts = this.events.filter(e =>
      e.type === 'prompt_start'
    ).length;

    const promptSuccesses = this.events.filter(e =>
      e.type === 'prompt_success'
    ).length;

    return {
      sessionSuccessRate: `${(sessionSuccesses / sessionAttempts * 100).toFixed(1)}%`,
      promptSuccessRate: `${(promptSuccesses / promptAttempts * 100).toFixed(1)}%`,
      totalEvents: this.events.length
    };
  }
}