Best Practices

// For chat applications - use smaller, faster models
await LlamaCPP.addModel({
  id: 'smollm2-360m',
  name: 'SmolLM2 360M',
  url: 'https://huggingface.co/.../SmolLM2-360M.Q8_0.gguf',
  memoryRequirement: 500_000_000,
})

// For quality-critical tasks - use larger models
await LlamaCPP.addModel({
  id: 'qwen-1.5b',
  name: 'Qwen 1.5B',
  url: 'https://huggingface.co/.../qwen-1.5b-q4_k_m.gguf',
  memoryRequirement: 1_500_000_000,
})

// Unload LLM when not in use
await RunAnywhere.unloadModel()

// Unload STT when not needed
await RunAnywhere.unloadSTTModel()

// Unload TTS when done
await RunAnywhere.unloadTTSModel()

import { useEffect } from 'react'
import { AppState, AppStateStatus } from 'react-native'
import { RunAnywhere } from '@runanywhere/core'

function useModelLifecycle(modelId: string) {
  useEffect(() => {
    const subscription = AppState.addEventListener('change', (state: AppStateStatus) => {
      if (state === 'background') {
        // Free memory when app backgrounds
        RunAnywhere.unloadModel()
      } else if (state === 'active') {
        // Optionally reload when app returns
        // This depends on your UX requirements
      }
    })

    return () => subscription.remove()
  }, [modelId])
}

async function safeLoadModel(modelId: string): Promise<boolean> {
  const modelInfo = await RunAnywhere.getModelInfo(modelId)
  const storage = await RunAnywhere.getStorageInfo()

  if (!modelInfo?.memoryRequired) {
    return false
  }

  // Check if we have enough free memory (with 20% buffer)
  const requiredWithBuffer = modelInfo.memoryRequired * 1.2

  if (storage.freeSpace < requiredWithBuffer) {
    console.warn('Insufficient memory for model')
    return false
  }

  await RunAnywhere.loadModel(modelInfo.localPath!)
  return true
}

// ❌ Bad: User waits for entire response
const result = await RunAnywhere.generate(prompt, { maxTokens: 500 })
setResponse(result.text)

// ✅ Good: User sees response as it's generated
const stream = await RunAnywhere.generateStream(prompt, { maxTokens: 500 })
for await (const token of stream.stream) {
  setResponse((prev) => prev + token)
}

// For quick responses
const quick = await RunAnywhere.generate(prompt, {
  maxTokens: 100, // Short responses
  temperature: 0.5, // Faster sampling
})

// For detailed responses
const detailed = await RunAnywhere.generate(prompt, {
  maxTokens: 500,
  temperature: 0.7,
})

async function generateSafely(prompt: string): Promise<string> {
  try {
    const result = await RunAnywhere.generate(prompt)
    return result.text
  } catch (error) {
    if (isSDKError(error)) {
      switch (error.code) {
        case SDKErrorCode.modelNotLoaded:
          // Try to load model and retry
          await loadDefaultModel()
          return generateSafely(prompt)
        case SDKErrorCode.insufficientMemory:
          // Use a smaller model
          return 'I need to use a smaller model. Please try again.'
        case SDKErrorCode.generationCancelled:
          return '' // Expected, don't show error
        default:
          return 'Sorry, I encountered an error. Please try again.'
      }
    }
    return 'An unexpected error occurred.'
  }
}

// Show loading states
const [status, setStatus] = useState<'idle' | 'loading' | 'generating' | 'error'>('idle')

async function generate() {
  setStatus('loading')
  try {
    const result = await RunAnywhere.generate(prompt)
    setStatus('idle')
    return result
  } catch (error) {
    setStatus('error')
    throw error
  }
}

async function getAIResponse(prompt: string): Promise<string> {
  // Try on-device first
  if (await RunAnywhere.isModelLoaded()) {
    try {
      return (await RunAnywhere.generate(prompt)).text
    } catch {
      // Fall through to fallback
    }
  }

  // Fallback to simpler response
  return "I'm still setting up. Please try again in a moment."
}

// ❌ Bad: Logging user prompts
console.log('User prompt:', prompt)
logger.debug('Generating response for:', prompt)

// ✅ Good: Log only metadata
logger.debug('Generating response', { promptLength: prompt.length })

// Development: Full logging, no auth
await RunAnywhere.initialize({
  environment: SDKEnvironment.Development,
})

// Production: Minimal logging, with auth
await RunAnywhere.initialize({
  environment: SDKEnvironment.Production,
  apiKey: process.env.RUNANYWHERE_API_KEY,
})

// Telemetry is only in Production mode
// Use Development mode to disable all telemetry
await RunAnywhere.initialize({
  environment: SDKEnvironment.Development, // No telemetry
})

// In tests, use the smallest available model
const testModel = 'smollm2-360m' // Fast for CI/CD

beforeAll(async () => {
  await RunAnywhere.initialize({ environment: SDKEnvironment.Development })
  LlamaCPP.register()
  // Download and load small model for tests
})

// Create a mock for unit tests
jest.mock('@runanywhere/core', () => ({
  RunAnywhere: {
    generate: jest.fn().mockResolvedValue({
      text: 'Mock response',
      tokensUsed: 10,
      latencyMs: 100,
    }),
    chat: jest.fn().mockResolvedValue('Mock response'),
  },
}))