@tryhamster/gerbil 1.0.0-rc.8 → 1.0.0

package/dist/index.mjs

@@ -1,14 +1,19 @@
-import { a as ResponseCache, c as getGlobalCache, i as resolveModel, n as BUILTIN_MODELS, o as clearGlobalCache, r as listBuiltinModels, s as configureGlobalCache, t as Gerbil } from "./gerbil-Dw4Qj77e.mjs";
-import { n as getChromeCachedModels, r as refreshCachedModelSizes, t as ChromeGPUBackend } from "./chrome-backend-CORwaIyC.mjs";
-import "./utils-CZBZ8dgR.mjs";
-import { c as stream, i as generate, n as embed, o as json, r as embedBatch, s as one_liner_default, t as dispose } from "./one-liner-s-lD8rCC.mjs";
-import { i as resampleAudio, n as WhisperSTT, r as decodeWav, t as WHISPER_MODELS } from "./stt-CpLYbGFd.mjs";
-import { a as TTS_MODELS, c as listTTSModels, n as KokoroTTS, s as getTTSModelConfig, t as KOKORO_VOICES } from "./tts-DeGANMNV.mjs";
+import { a as resolveModel, c as configureGlobalCache, i as listBuiltinModels, l as getGlobalCache, n as BUILTIN_MODELS, o as ResponseCache, r as DEFAULT_MODEL, s as clearGlobalCache, t as Gerbil } from "./gerbil-BHrJJIa4.mjs";
+import "./utils-DKO55ZmZ.mjs";
+import { a as generateObject, c as one_liner_default, i as generate, l as stream, n as embed, r as embedBatch, s as json, t as dispose } from "./one-liner-DnQn7HJK.mjs";
+import { t as DEFAULT_MODELS } from "./defaults-9komdrbY.mjs";
+import "./architectures-C1I5V3Dt.mjs";
+import { t as WebGPUEngine, y as KaniTTS } from "./gpu-33qCAtHW.mjs";
+import { t as MoonshineSTT } from "./moonshine-stt-v_P_Ci_m.mjs";
+import { a as createInMemoryStore, n as createMemory, t as Memory } from "./memory-Dj0J1v88.mjs";
+import { n as createFileStore, r as createGerbilEmbedder } from "./memory-DVN0MnIG.mjs";
+import "./vector-B0panuy6.mjs";
+import { n as createIndexedDBStore } from "./indexeddb-store-BWIMtxxH.mjs";
 
 //#region src/index.ts
 var src_default = one_liner_default;
-const VERSION = "0.1.0";
+const VERSION = "1.0.0";
 
 //#endregion
-export { BUILTIN_MODELS, ChromeGPUBackend, Gerbil, KOKORO_VOICES, KokoroTTS, ResponseCache, TTS_MODELS, VERSION, WHISPER_MODELS, WhisperSTT, clearGlobalCache, configureGlobalCache, decodeWav, src_default as default, dispose, embed, embedBatch, generate, getChromeCachedModels, getGlobalCache, getTTSModelConfig, json, listBuiltinModels, listTTSModels, refreshCachedModelSizes, resampleAudio, resolveModel, stream };
+export { BUILTIN_MODELS, DEFAULT_MODEL, DEFAULT_MODELS, Gerbil, KaniTTS, Memory, MoonshineSTT, ResponseCache, VERSION, WebGPUEngine, clearGlobalCache, configureGlobalCache, createFileStore, createGerbilEmbedder, createInMemoryStore, createIndexedDBStore, createMemory, src_default as default, dispose, embed, embedBatch, generate, generateObject, getGlobalCache, json, listBuiltinModels, resolveModel, stream };
 //# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","names":["gerbil"],"sources":["../src/index.ts"],"sourcesContent":["/**\n * Gerbil - Local LLM inference for Node.js\n *\n * @example Standalone\n * ```ts\n * import { Gerbil } from \"gerbil\";\n *\n * const g = new Gerbil();\n * await g.loadModel(\"qwen3-0.6b\");\n *\n * const result = await g.generate(\"Write a haiku\");\n * console.log(result.text);\n * ```\n *\n * @example One-liner\n * ```ts\n * import gerbil from \"gerbil\";\n *\n * const text = await gerbil(\"Write a haiku\");\n * ```\n *\n * @example AI SDK\n * ```ts\n * import { generateText } from \"ai\";\n * import { gerbil } from \"gerbil/ai\";\n *\n * const { text } = await generateText({\n *   model: gerbil(\"qwen3-0.6b\"),\n *   prompt: \"Write a haiku\",\n * });\n * ```\n *\n * @example Skills\n * ```ts\n * import { commit, summarize, explain, defineSkill } from \"gerbil/skills\";\n *\n * const msg = await commit({ type: \"conventional\" });\n * const summary = await summarize({ content: document });\n * ```\n */\n\nexport {\n  clearGlobalCache,\n  configureGlobalCache,\n  getGlobalCache,\n  ResponseCache,\n} from \"./core/cache.js\";\nexport {\n  ChromeGPUBackend,\n  getChromeCachedModels,\n  refreshCachedModelSizes,\n} from \"./core/chrome-backend.js\";\n// Core\nexport { Gerbil } from \"./core/gerbil.js\";\nexport { BUILTIN_MODELS, listBuiltinModels, resolveModel } from \"./core/models.js\";\n// One-liner API\nexport { dispose, embed, embedBatch, generate, json, stream } from \"./core/one-liner.js\";\n// STT (Speech-to-Text)\nexport { decodeWav, resampleAudio, WHISPER_MODELS, WhisperSTT } from \"./core/stt.js\";\n// TTS (Text-to-Speech)\nexport {\n  getTTSModelConfig,\n  KOKORO_VOICES,\n  KokoroTTS,\n  listTTSModels,\n  TTS_MODELS,\n} from \"./core/tts.js\";\n\nimport gerbil from \"./core/one-liner.js\";\nexport default gerbil;\n\n// Types\nexport type {\n  // TTS types\n  AudioChunk,\n  CacheConfig,\n  EmbedOptions,\n  EmbedResult,\n  FallbackConfig,\n  // Generation types\n  GenerateOptions,\n  GenerateResult,\n  // Config types\n  GerbilConfig,\n  // Provider types\n  GerbilModelSettings,\n  GerbilProviderSettings,\n  // Vision types\n  ImageInput,\n  JsonOptions,\n  // Load types\n  LoadOptions,\n  LoadSTTOptions,\n  LoadTTSOptions,\n  // Model types\n  ModelConfig,\n  ModelSource,\n  ModelStats,\n  ProgressInfo,\n  // Stats types\n  SessionStats,\n  SpeakOptions,\n  SpeakResult,\n  // STT types\n  STTModelConfig,\n  StreamingTranscriptionOptions,\n  StreamingTranscriptionSession,\n  SystemInfo,\n  TranscribeOptions,\n  TranscribeResult,\n  TranscribeSegment,\n  TTSModelConfig,\n  VoiceInfo,\n} from \"./core/types.js\";\n\n// Note: Task/Skill types are now in \"gerbil/skills\"\n// import { CommitInput, SummarizeInput, ... } from \"gerbil/skills\";\n\n// Version\nexport const VERSION = \"0.1.0\";\n"],"mappings":";;;;;;;;AAqEA,kBAAeA;AAkDf,MAAa,UAAU"}
+{"version":3,"file":"index.mjs","names":["gerbil"],"sources":["../src/index.ts"],"sourcesContent":["/**\n * Gerbil - Local LLM inference for Node.js\n *\n * @example Standalone\n * ```ts\n * import { Gerbil } from \"gerbil\";\n *\n * const g = new Gerbil();\n * await g.loadModel(\"qwen3.5-0.8b\");\n *\n * const result = await g.generate(\"Write a haiku\");\n * console.log(result.text);\n * ```\n *\n * @example One-liner\n * ```ts\n * import gerbil from \"gerbil\";\n *\n * const text = await gerbil(\"Write a haiku\");\n * ```\n *\n * @example AI SDK\n * ```ts\n * import { generateText } from \"ai\";\n * import { gerbil } from \"gerbil/ai\";\n *\n * const { text } = await generateText({\n *   model: gerbil(\"qwen3.5-0.8b\"),\n *   prompt: \"Write a haiku\",\n * });\n * ```\n *\n * @example Skills\n * ```ts\n * import { commit, summarize, explain, defineSkill } from \"gerbil/skills\";\n *\n * const msg = await commit({ type: \"conventional\" });\n * const summary = await summarize({ content: document });\n * ```\n */\n\nexport {\n  clearGlobalCache,\n  configureGlobalCache,\n  getGlobalCache,\n  ResponseCache,\n} from \"./core/cache.js\";\n// Core\nexport { Gerbil } from \"./core/gerbil.js\";\nexport {\n  BUILTIN_MODELS,\n  DEFAULT_MODEL,\n  listBuiltinModels,\n  resolveModel,\n} from \"./core/models.js\";\n// One-liner API\nexport {\n  dispose,\n  embed,\n  embedBatch,\n  generate,\n  generateObject,\n  json,\n  stream,\n} from \"./core/one-liner.js\";\n// Native WebGPU engine (pure compute shaders — no ONNX runtime)\nexport { DEFAULT_MODELS } from \"./gpu/defaults.js\";\nexport {\n  type GenerateObjectOptions,\n  type GenerateObjectResult,\n  type ObjectSchema,\n  type ObjectValidator,\n  WebGPUEngine,\n} from \"./gpu/index.js\";\n// Native TTS (Text-to-Speech) — Kani-TTS-2 codec LM on WebGPU\nexport {\n  KaniTTS,\n  type KaniTTSOptions,\n} from \"./gpu/kani-tts.js\";\n// Native STT (Speech-to-Text) — Moonshine encoder-decoder on WebGPU\nexport {\n  MoonshineSTT,\n  type MoonshineSTTOptions,\n} from \"./gpu/moonshine-stt.js\";\n\nimport gerbil from \"./core/one-liner.js\";\nexport default gerbil;\n\n// Types\nexport type {\n  // TTS types\n  AudioChunk,\n  CacheConfig,\n  // Concurrency types\n  ConcurrencyConfig,\n  EmbedOptions,\n  EmbedResult,\n  // Telemetry types\n  ErrorContext,\n  FallbackConfig,\n  GenerateEvent,\n  // Generation types\n  GenerateOptions,\n  GenerateResult,\n  // Config types\n  GerbilConfig,\n  // Provider types\n  GerbilModelSettings,\n  GerbilProviderSettings,\n  // Vision types\n  ImageInput,\n  JsonOptions,\n  // Load types\n  LoadOptions,\n  LoadSTTOptions,\n  LoadTTSOptions,\n  // Model types\n  ModelConfig,\n  ModelLoadEvent,\n  ModelSource,\n  ModelStats,\n  PreloadOptions,\n  ProgressInfo,\n  // Search/Similarity types\n  SearchResult,\n  // Stats types\n  SessionStats,\n  SimilarityResult,\n  SpeakOptions,\n  SpeakResult,\n  // STT types\n  STTModelConfig,\n  StreamingTranscriptionOptions,\n  StreamingTranscriptionSession,\n  SystemInfo,\n  TelemetryConfig,\n  TranscribeOptions,\n  TranscribeResult,\n  TranscribeSegment,\n  TTSModelConfig,\n  VoiceInfo,\n} from \"./core/types.js\";\n// Memory / RAG types (full surface available at \"gerbil/memory\")\nexport type {\n  AddOptions,\n  Embedder,\n  MemoryExport,\n  MemoryMetadata,\n  MemoryOptions,\n  MemoryRecord,\n  MemorySearchResult,\n  MemoryStore,\n  RecallOptions,\n  RecallResult,\n  Redactor,\n  SearchOptions as MemorySearchOptions,\n} from \"./memory/index.js\";\n// Memory / RAG (full surface available at \"gerbil/memory\")\nexport {\n  createFileStore,\n  createGerbilEmbedder,\n  createIndexedDBStore,\n  createInMemoryStore,\n  createMemory,\n  Memory,\n} from \"./memory/index.js\";\n\n// Note: Task/Skill types are now in \"gerbil/skills\"\n// import { CommitInput, SummarizeInput, ... } from \"gerbil/skills\";\n\n// Version\nexport const VERSION = \"1.0.0\";\n"],"mappings":";;;;;;;;;;;;;AAsFA,kBAAeA;AAqFf,MAAa,UAAU"}

package/dist/indexeddb-store-BWIMtxxH.mjs

@@ -0,0 +1,103 @@
+import { a as deserializeRecord, i as topK, o as matchesFilter, s as serializeRecord } from "./vector-B0panuy6.mjs";
+
+//#region src/memory/stores/indexeddb-store.ts
+/**
+* IndexedDB-backed {@link MemoryStore} for durable browser memory.
+*
+* Records persist across sessions. Embeddings are kept as plain number arrays
+* in the object store (structured-clone friendly) and rehydrated to
+* {@link Float32Array} on read. Search loads candidates and ranks them with
+* the same brute-force cosine scan as the in-memory store — fine for the
+* thousands-of-records scale this targets; see follow-ups for HNSW at scale.
+*/
+const DEFAULT_DB_NAME = "gerbil-memory";
+const DEFAULT_STORE_NAME = "records";
+const DEFAULT_K = 5;
+function promisifyRequest(request) {
+	return new Promise((resolve, reject) => {
+		request.onsuccess = () => resolve(request.result);
+		request.onerror = () => reject(request.error);
+	});
+}
+/** Durable IndexedDB vector store. */
+var IndexedDBStore = class {
+	dbName;
+	storeName;
+	factory;
+	dbPromise = null;
+	constructor(options = {}) {
+		this.dbName = options.dbName ?? DEFAULT_DB_NAME;
+		this.storeName = options.storeName ?? DEFAULT_STORE_NAME;
+		const factory = options.indexedDB ?? globalThis.indexedDB;
+		if (!factory) throw new Error("IndexedDB is not available. Pass an `indexedDB` factory (e.g. fake-indexeddb) to use IndexedDBStore outside a browser.");
+		this.factory = factory;
+	}
+	openDb() {
+		if (!this.dbPromise) this.dbPromise = new Promise((resolve, reject) => {
+			const request = this.factory.open(this.dbName, 1);
+			request.onupgradeneeded = () => {
+				const db = request.result;
+				if (!db.objectStoreNames.contains(this.storeName)) db.createObjectStore(this.storeName, { keyPath: "id" });
+			};
+			request.onsuccess = () => resolve(request.result);
+			request.onerror = () => reject(request.error);
+		});
+		return this.dbPromise;
+	}
+	async tx(mode) {
+		return (await this.openDb()).transaction(this.storeName, mode).objectStore(this.storeName);
+	}
+	async add(record) {
+		await promisifyRequest((await this.tx("readwrite")).put(serializeRecord(record)));
+	}
+	async addMany(records) {
+		const store = await this.tx("readwrite");
+		await Promise.all(records.map((record) => promisifyRequest(store.put(serializeRecord(record)))));
+	}
+	async get(id) {
+		const raw = await promisifyRequest((await this.tx("readonly")).get(id));
+		return raw ? deserializeRecord(raw) : void 0;
+	}
+	async all() {
+		return (await promisifyRequest((await this.tx("readonly")).getAll())).map(deserializeRecord);
+	}
+	async search(queryVector, options = {}) {
+		const k = options.k ?? DEFAULT_K;
+		const records = await this.all();
+		const candidates = [];
+		for (const record of records) {
+			if (!record.embedding) continue;
+			if (!matchesFilter(record.metadata, options.filter)) continue;
+			candidates.push({
+				item: record,
+				vector: record.embedding
+			});
+		}
+		return topK(queryVector, candidates, k, options.minScore).map((entry) => ({
+			record: entry.item,
+			score: entry.score
+		}));
+	}
+	async delete(id) {
+		if (!await this.get(id)) return false;
+		await promisifyRequest((await this.tx("readwrite")).delete(id));
+		return true;
+	}
+	async list(filter) {
+		return (await this.all()).filter((record) => matchesFilter(record.metadata, filter));
+	}
+	async clear() {
+		await promisifyRequest((await this.tx("readwrite")).clear());
+	}
+	async size() {
+		return await promisifyRequest((await this.tx("readonly")).count());
+	}
+};
+/** Create an {@link IndexedDBStore}. */
+function createIndexedDBStore(options = {}) {
+	return new IndexedDBStore(options);
+}
+
+//#endregion
+export { createIndexedDBStore as n, IndexedDBStore as t };
+//# sourceMappingURL=indexeddb-store-BWIMtxxH.mjs.map

package/dist/indexeddb-store-BWIMtxxH.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"indexeddb-store-BWIMtxxH.mjs","names":["candidates: { item: MemoryRecord; vector: Float32Array }[]"],"sources":["../src/memory/stores/indexeddb-store.ts"],"sourcesContent":["/**\n * IndexedDB-backed {@link MemoryStore} for durable browser memory.\n *\n * Records persist across sessions. Embeddings are kept as plain number arrays\n * in the object store (structured-clone friendly) and rehydrated to\n * {@link Float32Array} on read. Search loads candidates and ranks them with\n * the same brute-force cosine scan as the in-memory store — fine for the\n * thousands-of-records scale this targets; see follow-ups for HNSW at scale.\n */\n\nimport { deserializeRecord, matchesFilter, serializeRecord } from \"../serialize.js\";\nimport type {\n  MemoryRecord,\n  MemorySearchResult,\n  MemoryStore,\n  MetadataFilter,\n  SerializedRecord,\n  StoreSearchOptions,\n} from \"../types.js\";\nimport { type Scored, topK } from \"../vector.js\";\n\nconst DEFAULT_DB_NAME = \"gerbil-memory\";\nconst DEFAULT_STORE_NAME = \"records\";\nconst DEFAULT_K = 5;\n\n/** Options for {@link createIndexedDBStore}. */\nexport type IndexedDBStoreOptions = {\n  /** Database name (default \"gerbil-memory\"). */\n  dbName?: string;\n  /** Object store name (default \"records\"). */\n  storeName?: string;\n  /**\n   * IndexedDB factory. Defaults to the global `indexedDB` in browsers.\n   * Inject a shim (e.g. fake-indexeddb) to use this store under Node.\n   */\n  indexedDB?: IDBFactory;\n};\n\nfunction promisifyRequest<T>(request: IDBRequest<T>): Promise<T> {\n  return new Promise((resolve, reject) => {\n    request.onsuccess = () => resolve(request.result);\n    request.onerror = () => reject(request.error);\n  });\n}\n\n/** Durable IndexedDB vector store. */\nexport class IndexedDBStore implements MemoryStore {\n  private readonly dbName: string;\n  private readonly storeName: string;\n  private readonly factory: IDBFactory;\n  private dbPromise: Promise<IDBDatabase> | null = null;\n\n  constructor(options: IndexedDBStoreOptions = {}) {\n    this.dbName = options.dbName ?? DEFAULT_DB_NAME;\n    this.storeName = options.storeName ?? DEFAULT_STORE_NAME;\n    const factory = options.indexedDB ?? globalThis.indexedDB;\n    if (!factory) {\n      throw new Error(\n        \"IndexedDB is not available. Pass an `indexedDB` factory (e.g. fake-indexeddb) to use IndexedDBStore outside a browser.\",\n      );\n    }\n    this.factory = factory;\n  }\n\n  private openDb(): Promise<IDBDatabase> {\n    if (!this.dbPromise) {\n      this.dbPromise = new Promise((resolve, reject) => {\n        const request = this.factory.open(this.dbName, 1);\n        request.onupgradeneeded = () => {\n          const db = request.result;\n          if (!db.objectStoreNames.contains(this.storeName)) {\n            db.createObjectStore(this.storeName, { keyPath: \"id\" });\n          }\n        };\n        request.onsuccess = () => resolve(request.result);\n        request.onerror = () => reject(request.error);\n      });\n    }\n    return this.dbPromise;\n  }\n\n  private async tx(mode: IDBTransactionMode): Promise<IDBObjectStore> {\n    const db = await this.openDb();\n    return db.transaction(this.storeName, mode).objectStore(this.storeName);\n  }\n\n  async add(record: MemoryRecord): Promise<void> {\n    const store = await this.tx(\"readwrite\");\n    await promisifyRequest(store.put(serializeRecord(record)));\n  }\n\n  async addMany(records: MemoryRecord[]): Promise<void> {\n    const store = await this.tx(\"readwrite\");\n    await Promise.all(\n      records.map((record) => promisifyRequest(store.put(serializeRecord(record)))),\n    );\n  }\n\n  async get(id: string): Promise<MemoryRecord | undefined> {\n    const store = await this.tx(\"readonly\");\n    const raw = await promisifyRequest<SerializedRecord | undefined>(store.get(id));\n    return raw ? deserializeRecord(raw) : undefined;\n  }\n\n  private async all(): Promise<MemoryRecord[]> {\n    const store = await this.tx(\"readonly\");\n    const raw = await promisifyRequest<SerializedRecord[]>(store.getAll());\n    return raw.map(deserializeRecord);\n  }\n\n  async search(\n    queryVector: Float32Array,\n    options: StoreSearchOptions = {},\n  ): Promise<MemorySearchResult[]> {\n    const k = options.k ?? DEFAULT_K;\n    const records = await this.all();\n    const candidates: { item: MemoryRecord; vector: Float32Array }[] = [];\n    for (const record of records) {\n      if (!record.embedding) {\n        continue;\n      }\n      if (!matchesFilter(record.metadata, options.filter)) {\n        continue;\n      }\n      candidates.push({ item: record, vector: record.embedding });\n    }\n    const ranked: Scored<MemoryRecord>[] = topK(queryVector, candidates, k, options.minScore);\n    return ranked.map((entry) => ({ record: entry.item, score: entry.score }));\n  }\n\n  async delete(id: string): Promise<boolean> {\n    const existing = await this.get(id);\n    if (!existing) {\n      return false;\n    }\n    const store = await this.tx(\"readwrite\");\n    await promisifyRequest(store.delete(id));\n    return true;\n  }\n\n  async list(filter?: MetadataFilter): Promise<MemoryRecord[]> {\n    const records = await this.all();\n    return records.filter((record) => matchesFilter(record.metadata, filter));\n  }\n\n  async clear(): Promise<void> {\n    const store = await this.tx(\"readwrite\");\n    await promisifyRequest(store.clear());\n  }\n\n  async size(): Promise<number> {\n    const store = await this.tx(\"readonly\");\n    return await promisifyRequest<number>(store.count());\n  }\n}\n\n/** Create an {@link IndexedDBStore}. */\nexport function createIndexedDBStore(options: IndexedDBStoreOptions = {}): MemoryStore {\n  return new IndexedDBStore(options);\n}\n"],"mappings":"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"}

package/dist/indexeddb-store-ClH12Xnl.mjs

@@ -0,0 +1,4 @@
+import "./vector-B0panuy6.mjs";
+import { n as createIndexedDBStore, t as IndexedDBStore } from "./indexeddb-store-BWIMtxxH.mjs";
+
+export { IndexedDBStore, createIndexedDBStore };

package/dist/integrations/ai-sdk.d.mts

@@ -1,5 +1,5 @@
-import { b as STTModelConfig, g as ModelConfig, l as GerbilModelSettings, u as GerbilProviderSettings } from "../types-CiTc7ez3.mjs";
-import { LanguageModelV2, LanguageModelV2CallOptions, LanguageModelV2CallWarning, LanguageModelV2Content, LanguageModelV2FinishReason, LanguageModelV2StreamPart, LanguageModelV2Usage, SpeechModelV2, SpeechModelV2CallOptions, SpeechModelV2CallWarning, TranscriptionModelV2, TranscriptionModelV2CallOptions, TranscriptionModelV2CallWarning } from "@ai-sdk/provider";
+import { T as STTModelConfig, f as GerbilModelSettings, p as GerbilProviderSettings, y as ModelConfig } from "../types-D6FiR_oh.mjs";
+import { EmbeddingModelV2, LanguageModelV2, LanguageModelV2CallOptions, LanguageModelV2CallWarning, LanguageModelV2Content, LanguageModelV2FinishReason, LanguageModelV2StreamPart, LanguageModelV2Usage, SpeechModelV2, SpeechModelV2CallOptions, SpeechModelV2CallWarning, TranscriptionModelV2, TranscriptionModelV2CallOptions, TranscriptionModelV2CallWarning } from "@ai-sdk/provider";
 
 //#region src/integrations/ai-sdk.d.ts
 
@@ -103,11 +103,46 @@ declare class GerbilTranscriptionModel implements TranscriptionModelV2 {
     };
   }>;
 }
+/** Settings for Gerbil embedding model */
+interface GerbilEmbeddingSettings {
+  /** Normalize embeddings (default: true) */
+  normalize?: boolean;
+}
+/** Default embedding models */
+declare const EMBEDDING_MODELS: {
+  id: string;
+  repo: string;
+  description: string;
+  dimensions: number;
+}[];
+declare class GerbilEmbeddingModel implements EmbeddingModelV2<string> {
+  readonly specificationVersion: "v2";
+  readonly provider = "gerbil";
+  readonly modelId: string;
+  readonly maxEmbeddingsPerCall: number;
+  readonly supportsParallelCalls = false;
+  private instance;
+  private readonly settings;
+  private loadPromise;
+  constructor(modelId: string, settings?: GerbilEmbeddingSettings);
+  private getRepo;
+  private ensureLoaded;
+  doEmbed(options: {
+    values: string[];
+    abortSignal?: AbortSignal;
+  }): Promise<{
+    embeddings: number[][];
+    usage?: {
+      tokens: number;
+    };
+  }>;
+}
 type GerbilProvider = {
   (modelId: string, settings?: GerbilModelSettings): GerbilLanguageModel;
   languageModel(modelId: string, settings?: GerbilModelSettings): GerbilLanguageModel;
   speech(modelId?: string, settings?: GerbilSpeechSettings): GerbilSpeechModel;
   transcription(modelId?: string, settings?: GerbilTranscriptionSettings): GerbilTranscriptionModel;
+  embedding(modelId?: string, settings?: GerbilEmbeddingSettings): GerbilEmbeddingModel;
   listModels(): ModelConfig[];
   getModel(modelId: string): ModelConfig | undefined;
   listVoices(): Array<{
@@ -117,17 +152,33 @@ type GerbilProvider = {
     language: string;
   }>;
   listTranscriptionModels(): STTModelConfig[];
+  listEmbeddingModels(): typeof EMBEDDING_MODELS;
+  /**
+   * Preload a model (download without initializing)
+   *
+   * @param modelId - Model to preload
+   * @param options.keepLoaded - Keep model in memory for instant generateText() calls
+   */
+  preload(modelId: string, options?: {
+    onProgress?: (info: {
+      status: string;
+      progress?: number;
+    }) => void;
+    keepLoaded?: boolean;
+  }): Promise<void>;
+  /** Check if a model is cached */
+  isCached(modelId: string): Promise<boolean>;
 };
 /**
  * Create a Gerbil provider
  *
  * @example
  * ```ts
- * const local = createGerbil({ device: "gpu", dtype: "q4" });
+ * const local = createGerbil({ device: "webgpu", dtype: "q4" });
  *
  * // Text generation
  * const { text } = await generateText({
- *   model: local("qwen3-0.6b"),
+ *   model: local("qwen3.5-0.8b"),
  *   prompt: "Hello",
  * });
  *
@@ -155,7 +206,7 @@ declare function createGerbil(options?: GerbilProviderSettings): GerbilProvider;
  * import { gerbil } from "gerbil/ai";
  *
  * const { text } = await generateText({
- *   model: gerbil("qwen3-0.6b"),
+ *   model: gerbil("qwen3.5-0.8b"),
  *   prompt: "Hello",
  * });
  * ```
@@ -189,8 +240,26 @@ declare function createGerbil(options?: GerbilProviderSettings): GerbilProvider;
  * console.log(transcript.text);
  * console.log(transcript.segments); // Timestamped segments
  * ```
+ *
+ * @example Embeddings
+ * ```ts
+ * import { embed, embedMany } from "ai";
+ * import { gerbil } from "gerbil/ai";
+ *
+ * // Single embedding
+ * const { embedding } = await embed({
+ *   model: gerbil.embedding(), // all-MiniLM-L6-v2 by default
+ *   value: "Hello world",
+ * });
+ *
+ * // Multiple embeddings
+ * const { embeddings } = await embedMany({
+ *   model: gerbil.embedding(),
+ *   values: ["Hello", "World", "How are you?"],
+ * });
+ * ```
  */
 declare const gerbil: GerbilProvider;
 //#endregion
-export { GerbilProvider, GerbilSpeechSettings, GerbilTranscriptionSettings, createGerbil, gerbil as default, gerbil };
+export { EMBEDDING_MODELS, GerbilEmbeddingSettings, GerbilProvider, GerbilSpeechSettings, GerbilTranscriptionSettings, createGerbil, gerbil as default, gerbil };
 //# sourceMappingURL=ai-sdk.d.mts.map

package/dist/integrations/ai-sdk.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"ai-sdk.d.mts","names":[],"sources":["../../src/integrations/ai-sdk.ts"],"sourcesContent":[],"mappings":";;;;;cAwDM,mBAAA,YAA+B,eAsJe,CAAA;EAtJf,SAAA,oBAAA,EAAA,IAAA;EAAe,SAAA,QAAA,GAAA,QAAA;EAsOnC,SAAA,OAAA,EAAA,MAAoB;EAO/B,SAAA,aAAkB,EAvOE,MAuOF,CAAA,MAAA,EAvOiB,MAuOjB,EAAA,CAAA;EASiB,QAAA,QAAA;EAoBb,iBAAA,QAAA;EACjB,iBAAA,gBAAA;EACG,QAAA,WAAA;EAEa,WAAA,CAAA,OAAA,EAAA,MAAA,EAAA,QAAA,EA/Pb,mBA+Pa,EAAA,gBAAA,EA9PL,sBA8PK;EAJ4B,QAAA,YAAA;EA7BpB,QAAA,aAAA;EAAa,QAAA,eAAA;EAoI/B,UAAA,CAAA,OAAA,EA3QW,0BA2QgB,CAAA,EA3QU,OA2QV,CAAA;IAKtC,OAAA,wBAAyB,EAAA;IASU,YAAA,6BAAA;IAoBb,KAAA,sBAAA;IAEd,OAAA,EAAA;MAOA,IAAA,EAAA;QAGG,KAAA,EAAA,MAAA;QAZ6C,MAAA,EAAA,MAAA;MA7BpB,CAAA;IAAoB,CAAA;IAiHlD,QAAA,4BAAc,EAAA;EACK,CAAA,CAAA;EAAsB,QAAA,CAAA,OAAA,EAlV3B,0BAkV2B,CAAA,EAlVD,OAkVC,CAAA;IACT,MAAA,gBAAA,0BAAA,CAAA;IAAsB,OAAA,EAAA;MAC5B,IAAA,EAAA;QAAuB,KAAA,EAAA,MAAA;QAChB,MAAA,EAAA,MAAA;MAA8B,CAAA;IAC3D,CAAA;EACa,CAAA,CAAA;;;AAEc,UAzQ1B,oBAAA,CAyQ0B;EA8B3B;EA4EH,KAAA,CAAA,EAAA,MAAuB;;;;cA5W9B,iBAAA,YAA6B;;;;;;;0CASM;;sBAoBb,2BAA2B;WAC5C;cACG;;;;;iBAEa;;;;;;;;;;UAmGV,2BAAA;;;;cAKX,wBAAA,YAAoC;;;;;;;0CASD;;sBAoBb,kCAAkC;;cAEhD;;;;;;;cAOA;;;;;iBAGG;;;;;KAwEL,cAAA;+BACmB,sBAAsB;4CACT,sBAAsB;sCAC5B,uBAAuB;6CAChB,8BAA8B;gBAC3D;6BACa;gBACb;;;;;;6BACa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8Bb,YAAA,WAAsB,yBAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA4EvD,QAAM"}
+{"version":3,"file":"ai-sdk.d.mts","names":[],"sources":["../../src/integrations/ai-sdk.ts"],"sourcesContent":[],"mappings":";;;;;cAiFM,mBAAA,YAA+B,eAsJe,CAAA;EAtJf,SAAA,oBAAA,EAAA,IAAA;EAAe,SAAA,QAAA,GAAA,QAAA;EAsOnC,SAAA,OAAA,EAAA,MAAoB;EAO/B,SAAA,aAAkB,EAvOE,MAuOF,CAAA,MAAA,EAvOiB,MAuOjB,EAAA,CAAA;EASiB,QAAA,QAAA;EAoBb,iBAAA,QAAA;EACjB,iBAAA,gBAAA;EACG,QAAA,WAAA;EAEa,WAAA,CAAA,OAAA,EAAA,MAAA,EAAA,QAAA,EA/Pb,mBA+Pa,EAAA,gBAAA,EA9PL,sBA8PK;EAJ4B,QAAA,YAAA;EA7BpB,QAAA,aAAA;EAAa,QAAA,eAAA;EAoI/B,UAAA,CAAA,OAAA,EA3QW,0BA2QgB,CAAA,EA3QU,OA2QV,CAAA;IAKtC,OAAA,wBAAyB,EAAA;IASU,YAAA,6BAAA;IAoBb,KAAA,sBAAA;IAEd,OAAA,EAAA;MAOA,IAAA,EAAA;QAGG,KAAA,EAAA,MAAA;QAZ6C,MAAA,EAAA,MAAA;MA7BpB,CAAA;IAAoB,CAAA;IAkH7C,QAAA,4BAAuB,EAAA;EAM3B,CAAA,CAAA;EAqBP,QAAA,CAAA,OAAA,EA7WoB,0BA6WC,CAAA,EA7WyB,OA6WzB,CAAA;IAWc,MAAA,gBAAA,0BAAA,CAAA;IAwBkB,OAAA,EAAA;MAAgB,IAAA,EAAA;QAnCrC,KAAA,EAAA,MAAA;QAAgB,MAAA,EAAA,MAAA;MAsE1C,CAAA;IACmB,CAAA;EAAsB,CAAA,CAAA;;;AAEf,UAtWrB,oBAAA,CAsWqB;EAAuB;EAChB,KAAA,CAAA,EAAA,MAAA;EAA8B;EAClC,KAAA,CAAA,EAAA,MAAA;;cAjWnC,iBAAA,YAA6B,aAkWnB,CAAA;EACa,SAAA,oBAAA,EAAA,IAAA;EACb,SAAA,QAAA,GAAA,QAAA;EACa,SAAA,OAAA,EAAA,MAAA;EACG,QAAA,QAAA;EAa3B,iBAAA,QAAA;EAEwB,QAAA,WAAA;EAAO,WAAA,CAAA,OAAA,EAAA,MAAA,EAAA,QAAA,CAAA,EA5WK,oBA4WL;EA8BpB,QAAA,YAAY;EAqIf,UAAuB,CAAA,OAAA,EA3fR,wBA2fQ,CAAA,EA3fmB,OA2fnB,CAAA;WA1fzB;cACG;;;;;iBAEa;;;;;;;;;;UAmGV,2BAAA;;;;cAKX,wBAAA,YAAoC;;;;;;;0CASD;;sBAoBb,kCAAkC;;cAEhD;;;;;;;cAOA;;;;;iBAGG;;;;;;UAyEA,uBAAA;;;;;cAMJ;;;;;;cAqBP,oBAAA,YAAgC;;;;;;;;;0CAWG;;;;;kBAwBkB;MAAgB;;;;;;;KAmC/D,cAAA;+BACmB,sBAAsB;4CACT,sBAAsB;sCAC5B,uBAAuB;6CAChB,8BAA8B;yCAClC,0BAA0B;gBACnD;6BACa;gBACb;;;;;;6BACa;gCACG;;;;;;;;;;;;;MAa3B;;6BAEwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8Bb,YAAA,WAAsB,yBAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAqIvD,QAAM"}

package/dist/integrations/ai-sdk.mjs

@@ -1,9 +1,23 @@
-import { n as BUILTIN_MODELS, t as Gerbil } from "../gerbil-Dw4Qj77e.mjs";
-import "../utils-CZBZ8dgR.mjs";
-import { t as WHISPER_MODELS } from "../stt-CpLYbGFd.mjs";
-import { t as KOKORO_VOICES } from "../tts-DeGANMNV.mjs";
+import { n as BUILTIN_MODELS, t as Gerbil } from "../gerbil-BHrJJIa4.mjs";
+import "../utils-DKO55ZmZ.mjs";
 
 //#region src/integrations/ai-sdk.ts
+const NATIVE_VOICES = [{
+	id: "default",
+	name: "Default",
+	gender: "neutral",
+	language: "en-us",
+	description: "Kani-TTS-2 native voice"
+}];
+const NATIVE_TRANSCRIPTION_MODELS = [{
+	id: "moonshine-base",
+	repo: "UsefulSensors/moonshine-base",
+	description: "Moonshine native WebGPU STT",
+	size: "61M",
+	multilingual: false,
+	languages: ["en"],
+	sampleRate: 16e3
+}];
 let idCounter = 0;
 function generateId() {
 	return `gerbil-${Date.now()}-${idCounter += 1}`;
@@ -196,14 +210,14 @@ var GerbilSpeechModel = class {
 	async doGenerate(options) {
 		const warnings = [];
 		const g = await this.ensureLoaded();
-		let voice = options.voice || this.settings.voice || "af_heart";
-		if (!KOKORO_VOICES.find((v) => v.id === voice)) {
+		let voice = options.voice || this.settings.voice || "default";
+		if (!NATIVE_VOICES.find((v) => v.id === voice)) {
 			warnings.push({
 				type: "unsupported-setting",
 				setting: "voice",
-				details: `Unknown voice "${voice}", using default "af_heart"`
+				details: `Unknown voice "${voice}", using default`
 			});
-			voice = "af_heart";
+			voice = "default";
 		}
 		const speed = options.speed ?? this.settings.speed ?? 1;
 		if (options.outputFormat && options.outputFormat !== "wav" && options.outputFormat !== "raw") warnings.push({
@@ -328,16 +342,81 @@ var GerbilTranscriptionModel = class {
 		};
 	}
 };
+/** Default embedding models */
+const EMBEDDING_MODELS = [
+	{
+		id: "all-MiniLM-L6-v2",
+		repo: "Xenova/all-MiniLM-L6-v2",
+		description: "MiniLM L6 v2 - Fast, 384 dimensions",
+		dimensions: 384
+	},
+	{
+		id: "bge-small-en-v1.5",
+		repo: "Xenova/bge-small-en-v1.5",
+		description: "BGE Small EN v1.5 - High quality, 384 dimensions",
+		dimensions: 384
+	},
+	{
+		id: "gte-small",
+		repo: "Xenova/gte-small",
+		description: "GTE Small - General text embeddings, 384 dimensions",
+		dimensions: 384
+	}
+];
+var GerbilEmbeddingModel = class {
+	specificationVersion = "v2";
+	provider = "gerbil";
+	modelId;
+	maxEmbeddingsPerCall = Infinity;
+	supportsParallelCalls = false;
+	instance = null;
+	settings;
+	loadPromise = null;
+	constructor(modelId, settings = {}) {
+		this.modelId = modelId;
+		this.settings = settings;
+	}
+	getRepo() {
+		return EMBEDDING_MODELS.find((m) => m.id === this.modelId)?.repo || this.modelId;
+	}
+	async ensureLoaded() {
+		if (this.instance) return this.instance;
+		if (this.loadPromise) {
+			await this.loadPromise;
+			return this.instance;
+		}
+		this.instance = new Gerbil();
+		return this.instance;
+	}
+	async doEmbed(options) {
+		const g = await this.ensureLoaded();
+		const embeddings = [];
+		let totalTokens = 0;
+		for (const value of options.values) {
+			if (options.abortSignal?.aborted) throw new Error("Embedding aborted");
+			const result = await g.embed(value, {
+				model: this.getRepo(),
+				normalize: this.settings.normalize
+			});
+			embeddings.push(result.vector);
+			totalTokens += Math.ceil(value.length / 4);
+		}
+		return {
+			embeddings,
+			usage: { tokens: totalTokens }
+		};
+	}
+};
 /**
 * Create a Gerbil provider
 *
 * @example
 * ```ts
-* const local = createGerbil({ device: "gpu", dtype: "q4" });
+* const local = createGerbil({ device: "webgpu", dtype: "q4" });
 *
 * // Text generation
 * const { text } = await generateText({
-*   model: local("qwen3-0.6b"),
+*   model: local("qwen3.5-0.8b"),
 *   prompt: "Hello",
 * });
 *
@@ -356,22 +435,41 @@ var GerbilTranscriptionModel = class {
 * ```
 */
 function createGerbil(options = {}) {
-	const createModel = (modelId, settings = {}) => new GerbilLanguageModel(modelId, settings, options);
+	const modelCache = /* @__PURE__ */ new Map();
+	const createModel = (modelId, settings = {}) => {
+		const cached = modelCache.get(modelId);
+		if (cached) return cached;
+		return new GerbilLanguageModel(modelId, settings, options);
+	};
 	const createSpeechModel = (modelId = "kokoro-82m", settings = {}) => new GerbilSpeechModel(modelId, settings);
 	const createTranscriptionModel = (modelId = "whisper-tiny.en", settings = {}) => new GerbilTranscriptionModel(modelId, settings);
+	const createEmbeddingModel = (modelId = "all-MiniLM-L6-v2", settings = {}) => new GerbilEmbeddingModel(modelId, settings);
 	const provider = ((modelId, settings) => createModel(modelId, settings ?? {}));
 	provider.languageModel = createModel;
 	provider.speech = createSpeechModel;
 	provider.transcription = createTranscriptionModel;
+	provider.embedding = createEmbeddingModel;
 	provider.listModels = () => Object.values(BUILTIN_MODELS);
 	provider.getModel = (id) => BUILTIN_MODELS[id];
-	provider.listVoices = () => KOKORO_VOICES.map((v) => ({
+	provider.listVoices = () => NATIVE_VOICES.map((v) => ({
 		id: v.id,
 		name: v.name,
 		gender: v.gender,
 		language: v.language
 	}));
-	provider.listTranscriptionModels = () => WHISPER_MODELS;
+	provider.listTranscriptionModels = () => NATIVE_TRANSCRIPTION_MODELS;
+	provider.listEmbeddingModels = () => EMBEDDING_MODELS;
+	provider.preload = async (modelId, opts) => {
+		if (opts?.keepLoaded ?? false) {
+			const model = new GerbilLanguageModel(modelId, {}, options);
+			await model.ensureLoaded();
+			modelCache.set(modelId, model);
+		} else await new Gerbil().preloadModel(modelId, opts);
+	};
+	provider.isCached = async (modelId) => {
+		if (modelCache.has(modelId)) return true;
+		return new Gerbil().isModelCached(modelId);
+	};
 	return provider;
 }
 /**
@@ -383,7 +481,7 @@ function createGerbil(options = {}) {
 * import { gerbil } from "gerbil/ai";
 *
 * const { text } = await generateText({
-*   model: gerbil("qwen3-0.6b"),
+*   model: gerbil("qwen3.5-0.8b"),
 *   prompt: "Hello",
 * });
 * ```
@@ -417,10 +515,28 @@ function createGerbil(options = {}) {
 * console.log(transcript.text);
 * console.log(transcript.segments); // Timestamped segments
 * ```
+*
+* @example Embeddings
+* ```ts
+* import { embed, embedMany } from "ai";
+* import { gerbil } from "gerbil/ai";
+*
+* // Single embedding
+* const { embedding } = await embed({
+*   model: gerbil.embedding(), // all-MiniLM-L6-v2 by default
+*   value: "Hello world",
+* });
+*
+* // Multiple embeddings
+* const { embeddings } = await embedMany({
+*   model: gerbil.embedding(),
+*   values: ["Hello", "World", "How are you?"],
+* });
+* ```
 */
 const gerbil = createGerbil();
 var ai_sdk_default = gerbil;
 
 //#endregion
-export { createGerbil, ai_sdk_default as default, gerbil };
+export { EMBEDDING_MODELS, createGerbil, ai_sdk_default as default, gerbil };
 //# sourceMappingURL=ai-sdk.mjs.map