@forbocai/browser 0.5.9 → 0.6.1

package/dist/index.mjs

@@ -1,4 +1,8 @@
-// src/cortex.ts
+// src/browserCortexSlice.ts
+import { createSlice, createAsyncThunk, createEntityAdapter } from "@reduxjs/toolkit";
+import { cortexInitStart, cortexInitSuccess, cortexInitFailed } from "@forbocai/core";
+var _engines = {};
+var browserCortexAdapter = createEntityAdapter();
 var DEFAULT_MODEL = "smollm2-135m";
 var MODEL_ALIASES = {
   "smollm2-135m": "SmolLM2-135M-Instruct-q0f16-MLC",
@@ -7,168 +11,312 @@ 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 = 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(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(cortexInitSuccess(newStatus));
+      dispatch2(setDownloadState({ isDownloading: false, progress: 100 }));
+      return sessionInfo;
+    } catch (e) {
+      const error = e.message || "Unknown error";
+      dispatch2(cortexInitFailed(error));
+      dispatch2(setDownloadState({ isDownloading: false, progress: 0 }));
+      return rejectWithValue(error);
+    }
+  }
+);
+var completeBrowserCortexThunk = 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 = 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);
-
-// src/memory.ts
-import { memoiseAsync as memoiseAsync2 } from "@forbocai/core";
-
-// src/vector.ts
-import { memoiseAsync } from "@forbocai/core";
-var getEmbedder = 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();
+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/browserMemorySlice.ts
+import { createSlice as createSlice3, createAsyncThunk as createAsyncThunk3, createEntityAdapter as createEntityAdapter2 } from "@reduxjs/toolkit";
+import { memoryStoreStart, memoryStoreSuccess, memoryStoreFailed, memoryRecallStart, memoryRecallSuccess, memoryRecallFailed, memoryClear } from "@forbocai/core";
+
+// src/browserVectorSlice.ts
+import { createSlice as createSlice2, createAsyncThunk as createAsyncThunk2 } from "@reduxjs/toolkit";
+var _pipeline = null;
+var initialState = {
+  isReady: false,
+  error: null
 };
+var initBrowserVectorThunk = createAsyncThunk2(
+  "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 = createAsyncThunk2(
+  "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 = createSlice2({
+  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 = memoiseAsync2(async () => {
+// src/browserMemorySlice.ts
+var _dbs = {};
+var browserMemoryAdapter = createEntityAdapter2();
+var initBrowserMemoryThunk = createAsyncThunk3(
+  "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");
+    }
+    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 = createAsyncThunk3(
+  "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(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(memoryStoreSuccess(item));
+      return item;
+    } catch (e) {
+      const error = e.message || "Memory store failed";
+      dispatch2(memoryStoreFailed(error));
+      return rejectWithValue(error);
     }
-    const { create } = await import("@orama/orama");
-    return create({
-      schema: {
-        id: "string",
-        text: "string",
-        timestamp: "number",
-        type: "string",
-        importance: "number",
-        embedding: "vector[384]"
-      }
+  }
+);
+var recallBrowserMemoryThunk = createAsyncThunk3(
+  "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(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(memoryRecallSuccess(items));
+      return items;
+    } catch (e) {
+      const error = e.message || "Memory recall failed";
+      dispatch2(memoryRecallFailed(error));
+      return rejectWithValue(error);
+    }
+  }
+);
+var clearBrowserMemoryThunk = createAsyncThunk3(
+  "browser/memory/clear",
+  async ({ dbName = "default" } = {}, { dispatch: dispatch2 }) => {
+    delete _dbs[dbName];
+    dispatch2(memoryClear());
+  }
+);
+var browserMemorySlice = createSlice3({
+  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/store.ts
+import { createSDKStore } from "@forbocai/core";
+var createBrowserStore = () => {
+  return 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;
 export {
-  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
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forbocai/browser",
-  "version": "0.5.9",
+  "version": "0.6.1",
   "license": "UNLICENSED",
   "description": "Web Browser implementation for ForbocAI SDK",
   "main": "dist/index.js",
@@ -12,10 +12,11 @@
     "test": "vitest"
   },
   "dependencies": {
-    "@forbocai/core": "^0.5.9",
+    "@forbocai/core": "^0.6.1",
+    "@huggingface/transformers": "^3.0.0",
     "@mlc-ai/web-llm": "^0.2.46",
     "@orama/orama": "^2.0.26",
-    "@huggingface/transformers": "^3.0.0"
+    "@reduxjs/toolkit": "^2.11.2"
   },
   "devDependencies": {
     "tsup": "^8.5.1",