Best Practices

import { RunAnywhere } from '@runanywhere/core'
import { InferenceFramework, ModelCategory } from '@runanywhere/proto-ts/model_types'

// Chat: smaller and faster
await RunAnywhere.models.register({
  id: 'smollm2-360m-q8_0',
  name: 'SmolLM2 360M Q8_0',
  url: 'https://huggingface.co/prithivMLmods/SmolLM2-360M-GGUF/resolve/main/SmolLM2-360M.Q8_0.gguf',
  category: ModelCategory.MODEL_CATEGORY_LANGUAGE,
  framework: InferenceFramework.INFERENCE_FRAMEWORK_LLAMA_CPP,
  memoryRequirementBytes: 386_404_416,
})

// Quality-critical: larger
await RunAnywhere.models.register({
  id: 'mistral-7b-instruct-q4_k_m',
  name: 'Mistral 7B Instruct Q4_K_M',
  url: 'https://huggingface.co/TheBloke/Mistral-7B-Instruct-v0.1-GGUF/resolve/main/mistral-7b-instruct-v0.1.Q4_K_M.gguf',
  category: ModelCategory.MODEL_CATEGORY_LANGUAGE,
  framework: InferenceFramework.INFERENCE_FRAMEWORK_LLAMA_CPP,
  memoryRequirementBytes: 4_368_438_944,
})

import { ModelCategory } from '@runanywhere/proto-ts/model_types'

await RunAnywhere.models.unload(ModelCategory.MODEL_CATEGORY_LANGUAGE)
await RunAnywhere.models.unload() // everything

import { useEffect } from 'react'
import { AppState } from 'react-native'
import { RunAnywhere } from '@runanywhere/core'
import { ModelCategory } from '@runanywhere/proto-ts/model_types'

function useUnloadOnBackground() {
  useEffect(() => {
    const subscription = AppState.addEventListener('change', (state) => {
      if (state === 'background') {
        void RunAnywhere.models.unload(ModelCategory.MODEL_CATEGORY_LANGUAGE)
      }
    })
    return () => subscription.remove()
  }, [])
}

async function hasRoom(modelId: string): Promise<boolean> {
  const model = await RunAnywhere.models.get(modelId)
  const state = await RunAnywhere.models.state()
  if (!model) return false
  return state.storageFreeBytes > Number(model.downloadSizeBytes)
}

useEffect(() => {
  return () => {
    void sessionRef.current?.close()
  }
}, [])

// The user waits for everything
const result = await RunAnywhere.llm.generate(prompt, { maxOutputTokens: 500 })
setResponse(result.text)

// The user sees tokens as they arrive
const iterator = RunAnywhere.llm
  .generateStream(prompt, { maxOutputTokens: 500 })
  [Symbol.asyncIterator]()

const quick = await RunAnywhere.llm.generate(prompt, { maxOutputTokens: 100, temperature: 0.5 })
const detailed = await RunAnywhere.llm.generate(prompt, { maxOutputTokens: 500 })

async function prefetch(ids: string[], onProgress: (percent: number) => void) {
  for (let i = 0; i < ids.length; i++) {
    const iterator = RunAnywhere.models.download(ids[i])[Symbol.asyncIterator]()
    try {
      let step = await iterator.next()
      while (!step.done) {
        const event = step.value
        if (event.type === 'progress') {
          onProgress(((i + event.percent / 100) / ids.length) * 100)
        }
        step = await iterator.next()
      }
    } finally {
      await iterator.return?.()
    }
  }
}

import { isSDKException, ErrorCode } from '@runanywhere/core'

async function generateSafely(prompt: string): Promise<string> {
  try {
    return (await RunAnywhere.llm.generate(prompt)).text
  } catch (e) {
    if (!isSDKException(e)) throw e
    switch (e.code) {
      case ErrorCode.ERROR_CODE_MODEL_NOT_LOADED:
        await RunAnywhere.models.load(defaultModelId)
        return generateSafely(prompt)
      case ErrorCode.ERROR_CODE_INSUFFICIENT_MEMORY:
        return 'Not enough memory for this model.'
      default:
        return e.recoverySuggestion ?? 'Something went wrong. Please try again.'
    }
  }
}

import { ModelCategory } from '@runanywhere/proto-ts/model_types'

async function getAIResponse(prompt: string): Promise<string> {
  const loaded = await RunAnywhere.models.loaded(ModelCategory.MODEL_CATEGORY_LANGUAGE)
  if (loaded === null) return 'Still setting up. Try again in a moment.'
  try {
    return (await RunAnywhere.llm.generate(prompt)).text
  } catch {
    return 'Something went wrong. Try again.'
  }
}

// Leaks the prompt
console.log('User prompt:', prompt)

// Logs only shape
logger.debug('Generating response', { promptLength: prompt.length })

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

// Production: warning-level logging, credentials required
await RunAnywhere.initialize({
  environment: SDKEnvironment.SDK_ENVIRONMENT_PRODUCTION,
  apiKey: process.env.RUNANYWHERE_API_KEY,
})

const iterator = stream[Symbol.asyncIterator]()
try {
  let step = await iterator.next()
  while (!step.done) {
    handle(step.value)
    step = await iterator.next()
  }
} finally {
  await iterator.return?.()
}