@forbocai/browser 0.5.8 → 0.6.0

package/dist/index.js

@@ -30,17 +30,37 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  createBrowserCortex: () => createBrowserCortex,
-  createBrowserMemory: () => createBrowserMemory,
-  createCortex: () => createCortex,
-  createMemory: () => createMemory,
+  browserCortexSlice: () => browserCortexSlice,
+  browserMemorySlice: () => browserMemorySlice,
+  browserVectorSlice: () => browserVectorSlice,
+  clearBrowserMemoryThunk: () => clearBrowserMemoryThunk,
+  completeBrowserCortexThunk: () => completeBrowserCortexThunk,
+  createBrowserStore: () => createBrowserStore,
+  dispatch: () => dispatch,
+  generateBrowserEmbeddingThunk: () => generateBrowserEmbeddingThunk,
   generateEmbedding: () => generateEmbedding,
-  initVectorEngine: () => initVectorEngine
+  getBrowserEngine: () => getBrowserEngine,
+  initBrowserCortexThunk: () => initBrowserCortexThunk,
+  initBrowserMemoryThunk: () => initBrowserMemoryThunk,
+  initBrowserVectorThunk: () => initBrowserVectorThunk,
+  recallBrowserMemoryThunk: () => recallBrowserMemoryThunk,
+  selectAllBrowserCortexSessions: () => selectAllBrowserCortexSessions,
+  selectAllBrowserDBs: () => selectAllBrowserDBs,
+  selectBrowserCortexById: () => selectBrowserCortexById,
+  selectBrowserDBById: () => selectBrowserDBById,
+  setDownloadProgress: () => setDownloadProgress,
+  setDownloadState: () => setDownloadState,
+  store: () => store,
+  storeBrowserMemoryThunk: () => storeBrowserMemoryThunk
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/cortex.ts
+// src/browserCortexSlice.ts
+var import_toolkit = require("@reduxjs/toolkit");
+var import_core = require("@forbocai/core");
 var import_meta = {};
+var _engines = {};
+var browserCortexAdapter = (0, import_toolkit.createEntityAdapter)();
 var DEFAULT_MODEL = "smollm2-135m";
 var MODEL_ALIASES = {
   "smollm2-135m": "SmolLM2-135M-Instruct-q0f16-MLC",
@@ -49,169 +69,320 @@ var MODEL_ALIASES = {
   "llama3-8b": "Llama-3.1-8B-Instruct-q4f16_1-MLC"
 };
 var resolveModelId = (alias) => MODEL_ALIASES[alias] ?? alias;
-var yieldTokens = async function* (iterator) {
-  const { value, done } = await iterator.next();
-  if (done) return;
-  const content = value.choices[0]?.delta?.content || "";
-  if (content) yield content;
-  yield* yieldTokens(iterator);
-};
-var createBrowserCortex = (config = {}) => {
-  const friendlyModel = config.model || DEFAULT_MODEL;
-  const modelId = resolveModelId(friendlyModel);
-  let _state = {
-    engine: null,
-    status: {
-      id: "browser-init",
-      model: friendlyModel,
-      ready: false,
-      engine: "web-llm"
-    }
-  };
-  const init = async (onProgress) => {
-    if (_state.status.ready) return _state.status;
+var initBrowserCortexThunk = (0, import_toolkit.createAsyncThunk)(
+  "browser/cortex/init",
+  async ({ model = DEFAULT_MODEL, onProgress }, { dispatch: dispatch2, rejectWithValue }) => {
     if (typeof window === "undefined") {
-      throw new Error("BrowserCortex requires a browser environment");
+      return rejectWithValue("BrowserCortex requires a browser environment");
     }
-    const { CreateWebWorkerMLCEngine } = await import("@mlc-ai/web-llm");
-    const initProgressCallback = (report) => {
-      const match = report.text?.match(/(\d+)%/);
-      if (onProgress && match) onProgress(parseInt(match[1], 10));
-    };
-    const engine = await CreateWebWorkerMLCEngine(
-      new Worker(new URL("./worker.js", import_meta.url), { type: "module" }),
-      modelId,
-      { initProgressCallback }
-    );
-    _state = {
-      engine,
-      status: {
+    const modelId = resolveModelId(model);
+    dispatch2((0, import_core.cortexInitStart)());
+    dispatch2(setDownloadState({ isDownloading: true, progress: 0 }));
+    try {
+      const { CreateWebWorkerMLCEngine } = await import("@mlc-ai/web-llm");
+      const initProgressCallback = (report) => {
+        const match = report.text?.match(/(\d+)%/);
+        if (match) {
+          const progress = parseInt(match[1], 10);
+          dispatch2(setDownloadProgress(progress));
+          if (onProgress) onProgress(progress);
+        }
+      };
+      const engine = await CreateWebWorkerMLCEngine(
+        new Worker(new URL("./worker.js", import_meta.url), { type: "module" }),
+        modelId,
+        { initProgressCallback }
+      );
+      _engines[model] = engine;
+      const sessionInfo = {
+        id: model,
+        ready: true,
+        engine: "web-llm"
+      };
+      const newStatus = {
         id: `ctx_web_${Date.now()}`,
         model: modelId,
         ready: true,
         engine: "web-llm"
-      }
-    };
-    return _state.status;
-  };
-  const ensureReady = async () => {
-    if (!_state.status.ready) await init();
-    return _state;
-  };
-  const complete = async (prompt, options = {}) => {
-    const { engine } = await ensureReady();
-    const reply = await engine.chat.completions.create({
-      messages: [{ role: "user", content: prompt }],
-      max_gen_len: options.maxTokens,
-      temperature: options.temperature
-    });
-    return reply.choices[0].message.content || "";
-  };
-  const completeStream = async function* (prompt, options = {}) {
-    const { engine } = await ensureReady();
-    const chunks = await engine.chat.completions.create({
-      messages: [{ role: "user", content: prompt }],
-      max_gen_len: options.maxTokens,
-      temperature: options.temperature,
-      stream: true
+      };
+      dispatch2((0, import_core.cortexInitSuccess)(newStatus));
+      dispatch2(setDownloadState({ isDownloading: false, progress: 100 }));
+      return sessionInfo;
+    } catch (e) {
+      const error = e.message || "Unknown error";
+      dispatch2((0, import_core.cortexInitFailed)(error));
+      dispatch2(setDownloadState({ isDownloading: false, progress: 0 }));
+      return rejectWithValue(error);
+    }
+  }
+);
+var completeBrowserCortexThunk = (0, import_toolkit.createAsyncThunk)(
+  "browser/cortex/complete",
+  async ({ model = DEFAULT_MODEL, prompt, maxTokens, temperature }, { rejectWithValue }) => {
+    const engine = _engines[model];
+    if (!engine) {
+      return rejectWithValue(`Browser Cortex session not found for model: ${model}`);
+    }
+    try {
+      const reply = await engine.chat.completions.create({
+        messages: [{ role: "user", content: prompt }],
+        max_gen_len: maxTokens,
+        temperature
+      });
+      return reply.choices[0].message.content || "";
+    } catch (e) {
+      return rejectWithValue(e.message || "Inference failed");
+    }
+  }
+);
+var browserCortexSlice = (0, import_toolkit.createSlice)({
+  name: "browserCortex",
+  initialState: browserCortexAdapter.getInitialState({
+    progress: 0,
+    isDownloading: false,
+    error: null
+  }),
+  reducers: {
+    setDownloadProgress: (state, action) => {
+      state.progress = action.payload;
+    },
+    setDownloadState: (state, action) => {
+      state.isDownloading = action.payload.isDownloading;
+      state.progress = action.payload.progress;
+    }
+  },
+  extraReducers: (builder) => {
+    builder.addCase(initBrowserCortexThunk.fulfilled, (state, action) => {
+      browserCortexAdapter.upsertOne(state, action.payload);
+      state.error = null;
+    }).addCase(initBrowserCortexThunk.rejected, (state, action) => {
+      state.error = action.payload || "Init failed";
     });
-    yield* yieldTokens(chunks[Symbol.asyncIterator]());
-  };
-  return { init, complete, completeStream };
-};
-var createCortex = (config = {}) => createBrowserCortex(config);
+  }
+});
+var { setDownloadProgress, setDownloadState } = browserCortexSlice.actions;
+var {
+  selectById: selectBrowserCortexById,
+  selectAll: selectAllBrowserCortexSessions
+} = browserCortexAdapter.getSelectors((state) => state.browserCortex);
+var getBrowserEngine = (model = DEFAULT_MODEL) => _engines[model];
+var browserCortexSlice_default = browserCortexSlice.reducer;
 
-// src/memory.ts
+// src/browserMemorySlice.ts
+var import_toolkit3 = require("@reduxjs/toolkit");
 var import_core2 = require("@forbocai/core");
 
-// src/vector.ts
-var import_core = require("@forbocai/core");
-var getEmbedder = (0, import_core.memoiseAsync)(async () => {
-  if (typeof window === "undefined") {
-    throw new Error("BrowserVectorEngine requires a browser environment");
-  }
-  const { pipeline } = await import("@huggingface/transformers");
-  return pipeline("feature-extraction", "Xenova/all-MiniLM-L6-v2");
-});
-var initVectorEngine = async () => {
-  await getEmbedder();
+// src/browserVectorSlice.ts
+var import_toolkit2 = require("@reduxjs/toolkit");
+var _pipeline = null;
+var initialState = {
+  isReady: false,
+  error: null
 };
+var initBrowserVectorThunk = (0, import_toolkit2.createAsyncThunk)(
+  "browser/vector/init",
+  async (_, { rejectWithValue }) => {
+    if (typeof window === "undefined") {
+      return rejectWithValue("BrowserVector requires a browser environment");
+    }
+    try {
+      const { pipeline } = await import("@huggingface/transformers");
+      _pipeline = await pipeline("feature-extraction", "Xenova/all-MiniLM-L6-v2");
+    } catch (e) {
+      return rejectWithValue(e.message || "Failed to load Transformers.js");
+    }
+  }
+);
+var generateBrowserEmbeddingThunk = (0, import_toolkit2.createAsyncThunk)(
+  "browser/vector/generate",
+  async (text, { dispatch: dispatch2, rejectWithValue }) => {
+    if (!_pipeline) {
+      await dispatch2(initBrowserVectorThunk());
+    }
+    try {
+      const result = await _pipeline(text, { pooling: "mean", normalize: true });
+      return Array.from(result.data);
+    } catch (e) {
+      return rejectWithValue(e.message || "Embedding generation failed");
+    }
+  }
+);
 var generateEmbedding = async (text) => {
-  try {
-    const embedder = await getEmbedder();
-    const result = await embedder(text, { pooling: "mean", normalize: true });
-    return Array.from(result.data);
-  } catch (e) {
-    console.error("Browser embedding failed:", e);
-    return new Array(384).fill(0);
+  if (!_pipeline) {
+    const { pipeline } = await import("@huggingface/transformers");
+    _pipeline = await pipeline("feature-extraction", "Xenova/all-MiniLM-L6-v2");
   }
+  const result = await _pipeline(text, { pooling: "mean", normalize: true });
+  return Array.from(result.data);
 };
+var browserVectorSlice = (0, import_toolkit2.createSlice)({
+  name: "browserVector",
+  initialState,
+  reducers: {},
+  extraReducers: (builder) => {
+    builder.addCase(initBrowserVectorThunk.fulfilled, (state) => {
+      state.isReady = true;
+      state.error = null;
+    }).addCase(initBrowserVectorThunk.rejected, (state, action) => {
+      state.error = action.payload;
+    });
+  }
+});
+var browserVectorSlice_default = browserVectorSlice.reducer;
 
-// src/memory.ts
-var createBrowserMemory = (config = {}) => {
-  const getDb = (0, import_core2.memoiseAsync)(async () => {
+// src/browserMemorySlice.ts
+var _dbs = {};
+var browserMemoryAdapter = (0, import_toolkit3.createEntityAdapter)();
+var initBrowserMemoryThunk = (0, import_toolkit3.createAsyncThunk)(
+  "browser/memory/init",
+  async ({ dbName = "default" } = {}, { rejectWithValue }) => {
     if (typeof window === "undefined") {
-      throw new Error("BrowserMemory requires a browser environment");
+      return rejectWithValue("BrowserMemory requires a browser environment");
     }
-    const { create } = await import("@orama/orama");
-    return create({
-      schema: {
-        id: "string",
-        text: "string",
-        timestamp: "number",
-        type: "string",
-        importance: "number",
-        embedding: "vector[384]"
-      }
+    try {
+      const { create } = await import("@orama/orama");
+      const db = await create({
+        schema: {
+          id: "string",
+          text: "string",
+          timestamp: "number",
+          type: "string",
+          importance: "number",
+          embedding: "vector[384]"
+        }
+      });
+      _dbs[dbName] = db;
+      return { id: dbName, isInitialized: true };
+    } catch (e) {
+      return rejectWithValue(e.message || "Failed to initialize Orama");
+    }
+  }
+);
+var storeBrowserMemoryThunk = (0, import_toolkit3.createAsyncThunk)(
+  "browser/memory/store",
+  async ({ text, type = "observation", importance = 0.5, dbName = "default" }, { dispatch: dispatch2, rejectWithValue }) => {
+    let db = _dbs[dbName];
+    if (!db) {
+      const result = await dispatch2(initBrowserMemoryThunk({ dbName })).unwrap();
+      db = _dbs[result.id];
+    }
+    dispatch2((0, import_core2.memoryStoreStart)());
+    try {
+      const item = {
+        id: `mem_br_${Date.now()}_${Math.random().toString(36).substring(7)}`,
+        text,
+        timestamp: Date.now(),
+        type,
+        importance
+      };
+      const embedding = await generateEmbedding(text);
+      const { insert } = await import("@orama/orama");
+      await insert(db, { ...item, embedding });
+      dispatch2((0, import_core2.memoryStoreSuccess)(item));
+      return item;
+    } catch (e) {
+      const error = e.message || "Memory store failed";
+      dispatch2((0, import_core2.memoryStoreFailed)(error));
+      return rejectWithValue(error);
+    }
+  }
+);
+var recallBrowserMemoryThunk = (0, import_toolkit3.createAsyncThunk)(
+  "browser/memory/recall",
+  async ({ query, limit = 5, threshold = 0.5, dbName = "default" }, { dispatch: dispatch2, rejectWithValue }) => {
+    let db = _dbs[dbName];
+    if (!db) {
+      const result = await dispatch2(initBrowserMemoryThunk({ dbName })).unwrap();
+      db = _dbs[result.id];
+    }
+    dispatch2((0, import_core2.memoryRecallStart)());
+    try {
+      const embedding = await generateEmbedding(query);
+      const { search } = await import("@orama/orama");
+      const results = await search(db, {
+        mode: "vector",
+        vector: { value: embedding, property: "embedding" },
+        similarity: threshold,
+        limit
+      });
+      const items = results.hits.map((hit) => hit.document);
+      dispatch2((0, import_core2.memoryRecallSuccess)(items));
+      return items;
+    } catch (e) {
+      const error = e.message || "Memory recall failed";
+      dispatch2((0, import_core2.memoryRecallFailed)(error));
+      return rejectWithValue(error);
+    }
+  }
+);
+var clearBrowserMemoryThunk = (0, import_toolkit3.createAsyncThunk)(
+  "browser/memory/clear",
+  async ({ dbName = "default" } = {}, { dispatch: dispatch2 }) => {
+    delete _dbs[dbName];
+    dispatch2((0, import_core2.memoryClear)());
+  }
+);
+var browserMemorySlice = (0, import_toolkit3.createSlice)({
+  name: "browserMemory",
+  initialState: browserMemoryAdapter.getInitialState({
+    error: null
+  }),
+  reducers: {},
+  extraReducers: (builder) => {
+    builder.addCase(initBrowserMemoryThunk.fulfilled, (state, action) => {
+      browserMemoryAdapter.upsertOne(state, action.payload);
+      state.error = null;
+    }).addCase(initBrowserMemoryThunk.rejected, (state, action) => {
+      state.error = action.payload;
     });
+  }
+});
+var {
+  selectById: selectBrowserDBById,
+  selectAll: selectAllBrowserDBs
+} = browserMemoryAdapter.getSelectors((state) => state.browserMemory);
+var browserMemorySlice_default = browserMemorySlice.reducer;
+
+// src/worker.ts
+var import_web_llm = require("@mlc-ai/web-llm");
+var handler = new import_web_llm.WebWorkerMLCEngineHandler();
+self.onmessage = (msg) => {
+  handler.onmessage(msg);
+};
+
+// src/store.ts
+var import_core3 = require("@forbocai/core");
+var createBrowserStore = () => {
+  return (0, import_core3.createSDKStore)({
+    browserCortex: browserCortexSlice_default,
+    browserMemory: browserMemorySlice_default,
+    browserVector: browserVectorSlice_default
   });
-  const store = async (text, type = "observation", importance = 0.5) => {
-    const instance = await getDb();
-    const item = {
-      id: `mem_br_${Date.now()}_${Math.random().toString(36).substring(7)}`,
-      text,
-      timestamp: Date.now(),
-      type,
-      importance
-    };
-    const embedding = await generateEmbedding(text);
-    const { insert } = await import("@orama/orama");
-    await insert(instance, { ...item, embedding });
-    return item;
-  };
-  const recall = async (query, limit = 5, threshold) => {
-    const instance = await getDb();
-    const embedding = await generateEmbedding(query);
-    const { search } = await import("@orama/orama");
-    const results = await search(instance, {
-      mode: "vector",
-      vector: { value: embedding, property: "embedding" },
-      similarity: threshold ?? 0.5,
-      limit
-    });
-    return results.hits.map((hit) => hit.document);
-  };
-  const list = async (limit = 50, offset = 0) => {
-    const instance = await getDb();
-    const { search } = await import("@orama/orama");
-    const results = await search(instance, { term: "", limit: limit + offset });
-    return results.hits.slice(offset).map((hit) => hit.document);
-  };
-  const clear = async () => {
-  };
-  const exportMemories = async () => list(1e4);
-  const importMemories = async (memories) => {
-    await Promise.all(memories.map((m) => store(m.text, m.type, m.importance)));
-  };
-  return { store, recall, list, clear, export: exportMemories, import: importMemories };
 };
-var createMemory = (config = {}) => createBrowserMemory(config);
+var store = createBrowserStore();
+var dispatch = store.dispatch;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  createBrowserCortex,
-  createBrowserMemory,
-  createCortex,
-  createMemory,
+  browserCortexSlice,
+  browserMemorySlice,
+  browserVectorSlice,
+  clearBrowserMemoryThunk,
+  completeBrowserCortexThunk,
+  createBrowserStore,
+  dispatch,
+  generateBrowserEmbeddingThunk,
   generateEmbedding,
-  initVectorEngine
+  getBrowserEngine,
+  initBrowserCortexThunk,
+  initBrowserMemoryThunk,
+  initBrowserVectorThunk,
+  recallBrowserMemoryThunk,
+  selectAllBrowserCortexSessions,
+  selectAllBrowserDBs,
+  selectBrowserCortexById,
+  selectBrowserDBById,
+  setDownloadProgress,
+  setDownloadState,
+  store,
+  storeBrowserMemoryThunk
 });