import { transformers } from '@localmode/transformers';
import { embed, rerank } from '@localmode/core';

// Text Embeddings
const embeddingModel = transformers.embedding('Xenova/bge-small-en-v1.5');
const { embedding } = await embed({ model: embeddingModel, value: 'Hello world' });

// Reranking for RAG
const rerankerModel = transformers.reranker('Xenova/ms-marco-MiniLM-L-6-v2');
const { results } = await rerank({
  model: rerankerModel,
  query: 'What is machine learning?',
  documents: ['ML is a subset of AI...', 'Python is a language...'],
  topK: 5,
});

const model = transformers.embedding('Xenova/bge-small-en-v1.5', {
  quantized: true, // Use quantized model (smaller, faster)
  revision: 'main', // Model revision
  onProgress: (p) => {
    console.log(`Loading: ${(p.progress * 100).toFixed(1)}%`);
  },
});

import { preloadModel, isModelCached, getModelStorageUsage } from '@localmode/transformers';

// Check if model is cached
const cached = await isModelCached('Xenova/bge-small-en-v1.5');

// Preload model with progress
await preloadModel('Xenova/bge-small-en-v1.5', {
  onProgress: (p) => console.log(`${p.progress}% loaded`),
});

// Check storage usage
const usage = await getModelStorageUsage();

import { createTransformers } from '@localmode/transformers';

// Force WebGPU device
const gpuTransformers = createTransformers({
  device: 'webgpu',
  onProgress: (p) => console.log(`Loading: ${p.progress}%`),
});

const model = gpuTransformers.embedding('Xenova/bge-small-en-v1.5');

// Offload inference to a Web Worker
const workerTransformers = createTransformers({
  useWorker: true,
});

import { isWebGPUAvailable, getOptimalDevice } from '@localmode/transformers';

// Check if WebGPU is available
const webgpuAvailable = await isWebGPUAvailable();

if (webgpuAvailable) {
  console.log('WebGPU available, using GPU acceleration');
} else {
  console.log('Falling back to WASM');
}

// Get optimal device automatically
const device = await getOptimalDevice(); // 'webgpu' or 'wasm'

const model = transformers.embedding('Xenova/bge-small-en-v1.5', {
  device, // Uses WebGPU if available, otherwise WASM
});

import { transformers } from '@localmode/transformers';
import type { EmbeddingModel } from '@localmode/core';

// ✅ CORRECT: Create once, reuse everywhere
let embeddingModel: EmbeddingModel | null = null;

function getEmbeddingModel() {
  if (!embeddingModel) {
    embeddingModel = transformers.embedding('Xenova/bge-small-en-v1.5');
  }
  return embeddingModel;
}

// In your service functions
export async function embedText(text: string) {
  const model = getEmbeddingModel();
  return embed({ model, value: text });
}

// ❌ WRONG: Creating a new instance every call
export async function embedText(text: string) {
  const model = transformers.embedding('Xenova/bge-small-en-v1.5'); // Wasteful!
  return embed({ model, value: text });
}

import { transformers, isWebGPUAvailable } from '@localmode/transformers';

// Detect optimal device at app startup
const device = (await isWebGPUAvailable()) ? 'webgpu' : 'wasm';

// Pass device to model creation
const model = transformers.embedding('Xenova/bge-small-en-v1.5', {
  device,
  quantized: true,
});

// _services/embedding.service.ts
export class EmbeddingAbortError extends Error {
  constructor() {
    super('Embedding was cancelled');
    this.name = 'EmbeddingAbortError';
  }
}

export async function generateEmbeddings(
  texts: string[],
  signal?: AbortSignal
) {
  try {
    return await embedMany({ model: getModel(), values: texts, abortSignal: signal });
  } catch (error) {
    if (error instanceof Error && error.name === 'AbortError') {
      throw new EmbeddingAbortError();
    }
    throw error;
  }
}

// _hooks/use-embedding.ts
export function useEmbedding() {
  const store = useEmbeddingStore();
  const controllerRef = useRef<AbortController | null>(null);

  const generate = async (texts: string[]) => {
    // Cancel any in-flight request
    controllerRef.current?.abort();
    controllerRef.current = new AbortController();

    store.setLoading(true);
    store.clearError();

    try {
      const result = await generateEmbeddings(texts, controllerRef.current.signal);
      store.setResult(result);
    } catch (error) {
      if (error instanceof EmbeddingAbortError) {
        return; // Silently ignore — user cancelled
      }
      store.setError(error instanceof Error ? error.message : 'Unknown error');
    } finally {
      store.setLoading(false);
    }
  };

  const cancel = () => controllerRef.current?.abort();

  return { generate, cancel };
}

import { streamText } from '@localmode/core';
import { transformers } from '@localmode/transformers';

const model = transformers.languageModel('onnx-community/Qwen3.5-0.8B-ONNX');

// Qwen3.5 models have supportsVision: true
console.log(model.supportsVision); // true

const result = await streamText({
  model,
  prompt: '',
  messages: [{
    role: 'user',
    content: [
      { type: 'text', text: 'Describe this image.' },
      { type: 'image', data: base64Data, mimeType: 'image/png' },
    ],
  }],
});