ahok-skill 1.3.1

package/dist/memory/embed.js

@@ -0,0 +1,675 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEmbeddingInfo = exports.getEmbeddingProvider = exports.embed = exports.bufferToVector = exports.vectorToBuffer = exports.cosineSimilarity = exports.emb_dim = void 0;
+exports.embedForSector = embedForSector;
+exports.embedQueryForAllSectors = embedQueryForAllSectors;
+exports.gen_syn_emb = gen_syn_emb;
+exports.embedMultiSector = embedMultiSector;
+const cfg_1 = require("../core/cfg");
+const models_1 = require("../core/models");
+const hsg_1 = require("./hsg");
+const db_1 = require("../core/db");
+const text_1 = require("../utils/text");
+const client_bedrock_runtime_1 = require("@aws-sdk/client-bedrock-runtime");
+let gem_q = Promise.resolve();
+const emb_dim = () => cfg_1.env.vec_dim;
+exports.emb_dim = emb_dim;
+// Fetch with timeout to prevent hanging requests and enable fallback chain
+const EMBED_TIMEOUT_MS = Number(process.env.OM_EMBED_TIMEOUT_MS) || 30000;
+async function fetchWithTimeout(url, options) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), EMBED_TIMEOUT_MS);
+    try {
+        return await fetch(url, { ...options, signal: controller.signal });
+    }
+    finally {
+        clearTimeout(timeoutId);
+    }
+}
+const compress_vec = (v, td) => {
+    if (v.length <= td)
+        return v;
+    const c = new Float32Array(td), bs = v.length / td;
+    for (let i = 0; i < td; i++) {
+        const s = Math.floor(i * bs), e = Math.floor((i + 1) * bs);
+        let sum = 0, cnt = 0;
+        for (let j = s; j < e && j < v.length; j++) {
+            sum += v[j];
+            cnt++;
+        }
+        c[i] = cnt > 0 ? sum / cnt : 0;
+    }
+    let n = 0;
+    for (let i = 0; i < td; i++)
+        n += c[i] * c[i];
+    n = Math.sqrt(n);
+    if (n > 0)
+        for (let i = 0; i < td; i++)
+            c[i] /= n;
+    return Array.from(c);
+};
+const fuse_vecs = (syn, sem) => {
+    const synLength = syn.length;
+    const semLength = sem.length;
+    const totalLength = synLength + semLength;
+    const f = new Array(totalLength);
+    let sumOfSquares = 0;
+    for (let i = 0; i < synLength; i++) {
+        const val = syn[i] * 0.6;
+        f[i] = val;
+        sumOfSquares += val * val;
+    }
+    for (let i = 0; i < semLength; i++) {
+        const val = sem[i] * 0.4;
+        f[synLength + i] = val;
+        sumOfSquares += val * val;
+    }
+    if (sumOfSquares > 0) {
+        const norm = Math.sqrt(sumOfSquares);
+        for (let i = 0; i < totalLength; i++) {
+            f[i] /= norm;
+        }
+    }
+    return f;
+};
+async function embedForSector(t, s) {
+    console.error(`[EMBED] Provider: ${cfg_1.env.emb_kind}, Tier: ${cfg_1.tier}, Sector: ${s}`);
+    if (!hsg_1.sector_configs[s])
+        throw new Error(`Unknown sector: ${s}`);
+    if (cfg_1.tier === "hybrid")
+        return gen_syn_emb(t, s);
+    if (cfg_1.tier === "smart" && cfg_1.env.emb_kind !== "synthetic") {
+        const syn = gen_syn_emb(t, s), sem = await get_sem_emb(t, s), comp = compress_vec(sem, 128);
+        return fuse_vecs(syn, comp);
+    }
+    if (cfg_1.tier === "fast")
+        return gen_syn_emb(t, s);
+    return await get_sem_emb(t, s);
+}
+/**
+ * Batch embed query text for ALL sectors in one API call.
+ * This significantly improves query performance by reducing 5 sequential
+ * API calls to a single batched call (~4.5x faster for deep tier).
+ */
+async function embedQueryForAllSectors(query, sectors) {
+    // For hybrid/fast tiers, use synthetic embeddings (already fast)
+    if (cfg_1.tier === "hybrid" || cfg_1.tier === "fast") {
+        const result = {};
+        for (const s of sectors)
+            result[s] = gen_syn_emb(query, s);
+        return result;
+    }
+    // For deep/smart tiers with Gemini, batch all sectors in ONE API call
+    if (cfg_1.env.emb_kind === "gemini" && cfg_1.env.gemini_key) {
+        try {
+            const txts = {};
+            for (const s of sectors)
+                txts[s] = query;
+            return await emb_gemini(txts);
+        }
+        catch (e) {
+            console.error(`[EMBED] Gemini batch failed, falling back to sequential: ${e}`);
+        }
+    }
+    // Fallback: sequential embedding for each sector
+    const result = {};
+    for (const s of sectors)
+        result[s] = await embedForSector(query, s);
+    return result;
+}
+// Embed with a specific provider (throws on failure)
+async function embed_with_provider(provider, t, s) {
+    switch (provider) {
+        case "openai":
+            return await emb_openai(t, s);
+        case "gemini":
+            return (await emb_gemini({ [s]: t }))[s];
+        case "ollama":
+            return await emb_ollama(t, s);
+        case "aws":
+            return await emb_aws(t, s);
+        case "local":
+            return await emb_local(t, s);
+        case "synthetic":
+            return gen_syn_emb(t, s);
+        default:
+            throw new Error(`Unknown embedding provider: ${provider}`);
+    }
+}
+// Get semantic embedding with configurable fallback chain
+async function get_sem_emb(t, s) {
+    // Deduplicate providers to avoid wasteful retries (e.g., gemini,gemini,synthetic)
+    const providers = [...new Set([cfg_1.env.emb_kind, ...cfg_1.env.embedding_fallback])];
+    for (let i = 0; i < providers.length; i++) {
+        const provider = providers[i];
+        try {
+            const result = await embed_with_provider(provider, t, s);
+            if (i > 0) {
+                console.error(`[EMBED] Fallback to ${provider} succeeded for sector: ${s}`);
+            }
+            return result;
+        }
+        catch (e) {
+            const errMsg = e instanceof Error ? e.message : String(e);
+            const nextProvider = providers[i + 1];
+            if (nextProvider) {
+                console.error(`[EMBED] ${provider} failed: ${errMsg}, trying ${nextProvider}`);
+            }
+            else {
+                console.error(`[EMBED] All providers failed. Last error (${provider}): ${errMsg}. Using synthetic.`);
+                return gen_syn_emb(t, s);
+            }
+        }
+    }
+    // Fallback if providers array is empty (shouldn't happen with defaults)
+    return gen_syn_emb(t, s);
+}
+// Batch embedding with fallback chain support (for simple mode)
+async function emb_batch_with_fallback(txts) {
+    const providers = [...new Set([cfg_1.env.emb_kind, ...cfg_1.env.embedding_fallback])];
+    for (let i = 0; i < providers.length; i++) {
+        const provider = providers[i];
+        try {
+            let result;
+            switch (provider) {
+                case "gemini":
+                    result = await emb_gemini(txts);
+                    break;
+                case "openai":
+                    result = await emb_batch_openai(txts);
+                    break;
+                default:
+                    // For providers without batch support, embed each sector individually
+                    result = {};
+                    for (const [s, t] of Object.entries(txts)) {
+                        result[s] = await embed_with_provider(provider, t, s);
+                    }
+            }
+            if (i > 0) {
+                console.error(`[EMBED] Fallback to ${provider} succeeded for batch`);
+            }
+            return result;
+        }
+        catch (e) {
+            const errMsg = e instanceof Error ? e.message : String(e);
+            const nextProvider = providers[i + 1];
+            if (nextProvider) {
+                console.error(`[EMBED] ${provider} batch failed: ${errMsg}, trying ${nextProvider}`);
+            }
+            else {
+                console.error(`[EMBED] All providers failed for batch. Last error (${provider}): ${errMsg}. Using synthetic.`);
+                // Fall back to synthetic for all sectors
+                const result = {};
+                for (const [s, t] of Object.entries(txts)) {
+                    result[s] = gen_syn_emb(t, s);
+                }
+                return result;
+            }
+        }
+    }
+    // Fallback if providers array is empty
+    const result = {};
+    for (const [s, t] of Object.entries(txts)) {
+        result[s] = gen_syn_emb(t, s);
+    }
+    return result;
+}
+async function emb_openai(t, s) {
+    if (!cfg_1.env.openai_key)
+        throw new Error("OpenAI key missing");
+    const m = (0, models_1.get_model)(s, "openai");
+    const r = await fetchWithTimeout(`${cfg_1.env.openai_base_url.replace(/\/$/, "")}/embeddings`, {
+        method: "POST",
+        headers: {
+            "content-type": "application/json",
+            authorization: `Bearer ${cfg_1.env.openai_key}`,
+        },
+        body: JSON.stringify({
+            input: t,
+            model: cfg_1.env.openai_model || m,
+            dimensions: cfg_1.env.vec_dim,
+        }),
+    });
+    if (!r.ok)
+        throw new Error(`OpenAI: ${r.status}`);
+    return (await r.json()).data[0].embedding;
+}
+async function emb_batch_openai(txts) {
+    if (!cfg_1.env.openai_key)
+        throw new Error("OpenAI key missing");
+    const secs = Object.keys(txts), m = (0, models_1.get_model)("semantic", "openai");
+    const r = await fetchWithTimeout(`${cfg_1.env.openai_base_url.replace(/\/$/, "")}/embeddings`, {
+        method: "POST",
+        headers: {
+            "content-type": "application/json",
+            authorization: `Bearer ${cfg_1.env.openai_key}`,
+        },
+        body: JSON.stringify({
+            input: Object.values(txts),
+            model: cfg_1.env.openai_model || m,
+            dimensions: cfg_1.env.vec_dim,
+        }),
+    });
+    if (!r.ok)
+        throw new Error(`OpenAI batch: ${r.status}`);
+    const d = (await r.json()), out = {};
+    secs.forEach((s, i) => (out[s] = d.data[i].embedding));
+    return out;
+}
+const task_map = {
+    episodic: "RETRIEVAL_DOCUMENT",
+    semantic: "SEMANTIC_SIMILARITY",
+    procedural: "RETRIEVAL_DOCUMENT",
+    emotional: "CLASSIFICATION",
+    reflective: "SEMANTIC_SIMILARITY",
+};
+async function emb_gemini(txts) {
+    if (!cfg_1.env.gemini_key)
+        throw new Error("Gemini key missing");
+    const prom = gem_q.then(async () => {
+        const url = `https://generativelanguage.googleapis.com/v1beta/models/text-embedding-004:batchEmbedContents?key=${cfg_1.env.gemini_key}`;
+        for (let a = 0; a < 3; a++) {
+            try {
+                const reqs = Object.entries(txts).map(([s, t]) => ({
+                    model: "models/text-embedding-004",
+                    content: { parts: [{ text: t }] },
+                    taskType: task_map[s] || task_map.semantic,
+                }));
+                const r = await fetchWithTimeout(url, {
+                    method: "POST",
+                    headers: { "content-type": "application/json" },
+                    body: JSON.stringify({ requests: reqs }),
+                });
+                if (!r.ok) {
+                    if (r.status === 429) {
+                        const d = Math.min(parseInt(r.headers.get("retry-after") || "2") *
+                            1000, 1000 * Math.pow(2, a));
+                        console.error(`[EMBED] Gemini rate limit (${a + 1}/3), waiting ${d}ms`);
+                        await new Promise((x) => setTimeout(x, d));
+                        continue;
+                    }
+                    throw new Error(`Gemini: ${r.status}`);
+                }
+                const data = (await r.json()), out = {};
+                let i = 0;
+                for (const s of Object.keys(txts))
+                    out[s] = resize_vec(data.embeddings[i++].values, cfg_1.env.vec_dim);
+                await new Promise((x) => setTimeout(x, 1500));
+                return out;
+            }
+            catch (e) {
+                const errMsg = e instanceof Error ? e.message : String(e);
+                if (a === 2) {
+                    throw new Error(`Gemini failed after 3 attempts: ${errMsg}`);
+                }
+                console.error(`[EMBED] Gemini error (${a + 1}/3): ${errMsg}`);
+                await new Promise((x) => setTimeout(x, 1000 * Math.pow(2, a)));
+            }
+        }
+        throw new Error("Gemini: exhausted retries");
+    });
+    gem_q = prom.catch(() => { });
+    return prom;
+}
+async function emb_ollama(t, s) {
+    const m = (0, models_1.get_model)(s, "ollama");
+    const r = await fetchWithTimeout(`${cfg_1.env.ollama_url}/api/embeddings`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ model: m, prompt: t }),
+    });
+    if (!r.ok)
+        throw new Error(`Ollama: ${r.status}`);
+    return resize_vec((await r.json()).embedding, cfg_1.env.vec_dim);
+}
+async function emb_aws(t, s) {
+    if (!cfg_1.env.AWS_REGION)
+        throw new Error("AWS_REGION missing");
+    if (!cfg_1.env.AWS_ACCESS_KEY_ID)
+        throw new Error("AWS_ACCESS_KEY_ID missing");
+    if (!cfg_1.env.AWS_SECRET_ACCESS_KEY)
+        throw new Error("AWS_SECRET_ACCESS_KEY missing");
+    const m = (0, models_1.get_model)(s, "aws");
+    const client = new client_bedrock_runtime_1.BedrockRuntimeClient({ region: process.env.AWS_REGION });
+    const dim = [256, 512, 1024].find((x) => x >= cfg_1.env.vec_dim) ?? 1024;
+    const params = {
+        modelId: m,
+        contentType: "application/json",
+        accept: "*/*",
+        body: JSON.stringify({
+            inputText: t,
+            dimensions: dim,
+        }),
+    };
+    const command = new client_bedrock_runtime_1.InvokeModelCommand(params);
+    try {
+        const response = await client.send(command);
+        const jsonString = new TextDecoder().decode(response.body);
+        const parsedResponse = JSON.parse(jsonString);
+        return resize_vec(parsedResponse.embedding, cfg_1.env.vec_dim);
+    }
+    catch (error) {
+        throw new Error(`AWS: ${error}`);
+    }
+}
+async function emb_local(t, s) {
+    if (!cfg_1.env.local_model_path) {
+        console.error("[EMBED] Local model missing, using synthetic");
+        return gen_syn_emb(t, s);
+    }
+    try {
+        const { createHash } = await Promise.resolve().then(() => __importStar(require("crypto")));
+        const h = createHash("sha256")
+            .update(t + s)
+            .digest(), e = [];
+        for (let i = 0; i < cfg_1.env.vec_dim; i++) {
+            const b1 = h[i % h.length], b2 = h[(i + 1) % h.length];
+            e.push(((b1 * 256 + b2) / 65535) * 2 - 1);
+        }
+        const n = Math.sqrt(e.reduce((sum, v) => sum + v * v, 0));
+        return e.map((v) => v / n);
+    }
+    catch {
+        console.error("[EMBED] Local embedding failed, using synthetic");
+        return gen_syn_emb(t, s);
+    }
+}
+const h1 = (v) => {
+    let h = 0x811c9dc5 | 0;
+    for (let i = 0; i < v.length; i++)
+        h = Math.imul(h ^ v.charCodeAt(i), 16777619);
+    return h >>> 0;
+};
+const h2 = (v, sd) => {
+    let h = sd | 0;
+    for (let i = 0; i < v.length; i++) {
+        h = Math.imul(h ^ v.charCodeAt(i), 0x5bd1e995);
+        h = (h >>> 13) ^ h;
+    }
+    return h >>> 0;
+};
+const add_feat = (vec, dim, k, w) => {
+    const h = h1(k), h_2 = h2(k, 0xdeadbeef), val = w * (1 - ((h & 1) << 1));
+    if (dim > 0 && (dim & (dim - 1)) === 0) {
+        vec[h & (dim - 1)] += val;
+        vec[h_2 & (dim - 1)] += val * 0.5;
+    }
+    else {
+        vec[h % dim] += val;
+        vec[h_2 % dim] += val * 0.5;
+    }
+};
+const add_pos_feat = (vec, dim, pos, w) => {
+    const idx = pos % dim, ang = pos / Math.pow(10000, (2 * idx) / dim);
+    vec[idx] += w * Math.sin(ang);
+    vec[(idx + 1) % dim] += w * Math.cos(ang);
+};
+const sec_wts = {
+    episodic: 1.3,
+    semantic: 1.0,
+    procedural: 1.2,
+    emotional: 1.4,
+    reflective: 0.9,
+};
+const norm_v = (v) => {
+    let n = 0;
+    for (let i = 0; i < v.length; i++)
+        n += v[i] * v[i];
+    if (n === 0)
+        return;
+    const inv = 1 / Math.sqrt(n);
+    for (let i = 0; i < v.length; i++)
+        v[i] *= inv;
+};
+function gen_syn_emb(t, s) {
+    const d = cfg_1.env.vec_dim || 768, v = new Float32Array(d).fill(0), ct = (0, text_1.canonical_tokens_from_text)(t);
+    if (!ct.length) {
+        const x = 1 / Math.sqrt(d);
+        return Array.from({ length: d }, () => x);
+    }
+    const et = Array.from((0, text_1.add_synonym_tokens)(ct)), tc = new Map(), el = et.length;
+    for (let i = 0; i < el; i++) {
+        const tok = et[i];
+        tc.set(tok, (tc.get(tok) || 0) + 1);
+    }
+    const sw = sec_wts[s] || 1.0, dl = Math.log(1 + el);
+    for (const [tok, c] of tc) {
+        const tf = c / el, idf = Math.log(1 + el / c), w = (tf * idf + 1) * sw;
+        add_feat(v, d, `${s}|tok|${tok}`, w);
+        if (tok.length >= 3)
+            for (let i = 0; i < tok.length - 2; i++)
+                add_feat(v, d, `${s}|c3|${tok.slice(i, i + 3)}`, w * 0.4);
+        if (tok.length >= 4)
+            for (let i = 0; i < tok.length - 3; i++)
+                add_feat(v, d, `${s}|c4|${tok.slice(i, i + 4)}`, w * 0.3);
+    }
+    for (let i = 0; i < ct.length - 1; i++) {
+        const a = ct[i], b = ct[i + 1];
+        if (a && b) {
+            const pw = 1.0 / (1.0 + i * 0.1);
+            add_feat(v, d, `${s}|bi|${a}_${b}`, 1.4 * sw * pw);
+        }
+    }
+    for (let i = 0; i < ct.length - 2; i++) {
+        const a = ct[i], b = ct[i + 1], c = ct[i + 2];
+        if (a && b && c)
+            add_feat(v, d, `${s}|tri|${a}_${b}_${c}`, 1.0 * sw);
+    }
+    for (let i = 0; i < Math.min(ct.length - 2, 20); i++) {
+        const a = ct[i], c = ct[i + 2];
+        if (a && c)
+            add_feat(v, d, `${s}|skip|${a}_${c}`, 0.7 * sw);
+    }
+    for (let i = 0; i < Math.min(ct.length, 50); i++)
+        add_pos_feat(v, d, i, (0.5 * sw) / dl);
+    const lb = Math.min(Math.floor(Math.log2(el + 1)), 10);
+    add_feat(v, d, `${s}|len|${lb}`, 0.6 * sw);
+    const dens = tc.size / el, db = Math.floor(dens * 10);
+    add_feat(v, d, `${s}|dens|${db}`, 0.5 * sw);
+    norm_v(v);
+    return Array.from(v);
+}
+const resize_vec = (v, t) => {
+    if (v.length === t)
+        return v;
+    if (v.length > t)
+        return v.slice(0, t);
+    return [...v, ...Array(t - v.length).fill(0)];
+};
+async function embedMultiSector(id, txt, secs, chunks) {
+    const r = [];
+    await db_1.q.ins_log.run(id, "multi-sector", "pending", Date.now(), null);
+    for (let a = 0; a < 3; a++) {
+        try {
+            const simp = cfg_1.env.embed_mode === "simple";
+            if (simp &&
+                (cfg_1.env.emb_kind === "gemini" || cfg_1.env.emb_kind === "openai")) {
+                console.error(`[EMBED] Simple mode (1 batch for ${secs.length} sectors)`);
+                const tb = {};
+                secs.forEach((s) => (tb[s] = txt));
+                // Use batch embedding with fallback support
+                const b = await emb_batch_with_fallback(tb);
+                Object.entries(b).forEach(([s, v]) => r.push({ sector: s, vector: v, dim: v.length }));
+            }
+            else {
+                console.error(`[EMBED] Advanced mode (${secs.length} calls)`);
+                const par = cfg_1.env.adv_embed_parallel && cfg_1.env.emb_kind !== "gemini";
+                if (par) {
+                    const p = secs.map(async (s) => {
+                        let v;
+                        if (chunks && chunks.length > 1) {
+                            const cv = [];
+                            for (const c of chunks)
+                                cv.push(await embedForSector(c.text, s));
+                            v = agg_chunks(cv);
+                        }
+                        else
+                            v = await embedForSector(txt, s);
+                        return { sector: s, vector: v, dim: v.length };
+                    });
+                    r.push(...(await Promise.all(p)));
+                }
+                else {
+                    for (let i = 0; i < secs.length; i++) {
+                        const s = secs[i];
+                        let v;
+                        if (chunks && chunks.length > 1) {
+                            const cv = [];
+                            for (const c of chunks)
+                                cv.push(await embedForSector(c.text, s));
+                            v = agg_chunks(cv);
+                        }
+                        else
+                            v = await embedForSector(txt, s);
+                        r.push({ sector: s, vector: v, dim: v.length });
+                        if (cfg_1.env.embed_delay_ms > 0 && i < secs.length - 1)
+                            await new Promise((x) => setTimeout(x, cfg_1.env.embed_delay_ms));
+                    }
+                }
+            }
+            await db_1.q.upd_log.run("completed", null, id);
+            return r;
+        }
+        catch (e) {
+            if (a === 2) {
+                await db_1.q.upd_log.run("failed", e instanceof Error ? e.message : String(e), id);
+                throw e;
+            }
+            await new Promise((x) => setTimeout(x, 1000 * Math.pow(2, a)));
+        }
+    }
+    throw new Error("Embedding failed after retries");
+}
+const agg_chunks = (vecs) => {
+    if (!vecs.length)
+        throw new Error("No vectors");
+    if (vecs.length === 1)
+        return vecs[0];
+    const d = vecs[0].length, r = Array(d).fill(0);
+    for (const v of vecs)
+        for (let i = 0; i < d; i++)
+            r[i] += v[i];
+    return r.map((x) => x / vecs.length);
+};
+const cosineSimilarity = (a, b) => {
+    if (a.length !== b.length)
+        return 0;
+    let dot = 0, na = 0, nb = 0;
+    for (let i = 0; i < a.length; i++) {
+        dot += a[i] * b[i];
+        na += a[i] * a[i];
+        nb += b[i] * b[i];
+    }
+    return na && nb ? dot / (Math.sqrt(na) * Math.sqrt(nb)) : 0;
+};
+exports.cosineSimilarity = cosineSimilarity;
+const vectorToBuffer = (v) => {
+    const b = Buffer.allocUnsafe(v.length * 4);
+    for (let i = 0; i < v.length; i++)
+        b.writeFloatLE(v[i], i * 4);
+    return b;
+};
+exports.vectorToBuffer = vectorToBuffer;
+const bufferToVector = (b) => {
+    const v = [];
+    for (let i = 0; i < b.length; i += 4)
+        v.push(b.readFloatLE(i));
+    return v;
+};
+exports.bufferToVector = bufferToVector;
+const embed = (t) => embedForSector(t, "semantic");
+exports.embed = embed;
+const getEmbeddingProvider = () => cfg_1.env.emb_kind;
+exports.getEmbeddingProvider = getEmbeddingProvider;
+const getEmbeddingInfo = () => {
+    const i = {
+        provider: cfg_1.env.emb_kind,
+        fallback_chain: cfg_1.env.embedding_fallback,
+        dimensions: cfg_1.env.vec_dim,
+        mode: cfg_1.env.embed_mode,
+        batch_support: cfg_1.env.embed_mode === "simple" &&
+            (cfg_1.env.emb_kind === "gemini" || cfg_1.env.emb_kind === "openai"),
+        advanced_parallel: cfg_1.env.adv_embed_parallel,
+        embed_delay_ms: cfg_1.env.embed_delay_ms,
+    };
+    if (cfg_1.env.emb_kind === "openai") {
+        i.configured = !!cfg_1.env.openai_key;
+        i.base_url = cfg_1.env.openai_base_url;
+        i.model_override = cfg_1.env.openai_model || null;
+        i.batch_api = cfg_1.env.embed_mode === "simple";
+        i.models = {
+            episodic: (0, models_1.get_model)("episodic", "openai"),
+            semantic: (0, models_1.get_model)("semantic", "openai"),
+            procedural: (0, models_1.get_model)("procedural", "openai"),
+            emotional: (0, models_1.get_model)("emotional", "openai"),
+            reflective: (0, models_1.get_model)("reflective", "openai"),
+        };
+    }
+    else if (cfg_1.env.emb_kind === "gemini") {
+        i.configured = !!cfg_1.env.gemini_key;
+        i.batch_api = cfg_1.env.embed_mode === "simple";
+        i.model = "embedding-001";
+    }
+    else if (cfg_1.env.emb_kind === "aws") {
+        i.configured =
+            !!cfg_1.env.AWS_REGION &&
+                !!cfg_1.env.AWS_ACCESS_KEY_ID &&
+                !!cfg_1.env.AWS_SECRET_ACCESS_KEY;
+        i.batch_api = cfg_1.env.embed_mode === "simple";
+        i.model = "amazon.titan-embed-text-v2:0";
+    }
+    else if (cfg_1.env.emb_kind === "ollama") {
+        i.configured = true;
+        i.url = cfg_1.env.ollama_url;
+        i.models = {
+            episodic: (0, models_1.get_model)("episodic", "ollama"),
+            semantic: (0, models_1.get_model)("semantic", "ollama"),
+            procedural: (0, models_1.get_model)("procedural", "ollama"),
+            emotional: (0, models_1.get_model)("emotional", "ollama"),
+            reflective: (0, models_1.get_model)("reflective", "ollama"),
+        };
+    }
+    else if (cfg_1.env.emb_kind === "local") {
+        i.configured = !!cfg_1.env.local_model_path;
+        i.path = cfg_1.env.local_model_path;
+    }
+    else {
+        i.configured = true;
+        i.type = "synthetic";
+    }
+    return i;
+};
+exports.getEmbeddingInfo = getEmbeddingInfo;