@poolzin/pool-bot 2026.1.39 → 2026.2.1

package/dist/memory/backend-config.js

@@ -0,0 +1,207 @@
+import path from "node:path";
+import { resolveAgentWorkspaceDir } from "../agents/agent-scope.js";
+import { parseDurationMs } from "../cli/parse-duration.js";
+import { resolveUserPath } from "../utils.js";
+import { splitShellArgs } from "../utils/shell-argv.js";
+const DEFAULT_BACKEND = "builtin";
+const DEFAULT_CITATIONS = "auto";
+const DEFAULT_QMD_INTERVAL = "5m";
+const DEFAULT_QMD_DEBOUNCE_MS = 15_000;
+const DEFAULT_QMD_TIMEOUT_MS = 4_000;
+const DEFAULT_QMD_EMBED_INTERVAL = "60m";
+const DEFAULT_QMD_COMMAND_TIMEOUT_MS = 30_000;
+const DEFAULT_QMD_UPDATE_TIMEOUT_MS = 120_000;
+const DEFAULT_QMD_EMBED_TIMEOUT_MS = 120_000;
+const DEFAULT_QMD_LIMITS = {
+    maxResults: 6,
+    maxSnippetChars: 700,
+    maxInjectedChars: 4_000,
+    timeoutMs: DEFAULT_QMD_TIMEOUT_MS,
+};
+const DEFAULT_QMD_SCOPE = {
+    default: "deny",
+    rules: [
+        {
+            action: "allow",
+            match: { chatType: "direct" },
+        },
+    ],
+};
+function sanitizeName(input) {
+    const lower = input.toLowerCase().replace(/[^a-z0-9-]+/g, "-");
+    const trimmed = lower.replace(/^-+|-+$/g, "");
+    return trimmed || "collection";
+}
+function ensureUniqueName(base, existing) {
+    let name = sanitizeName(base);
+    if (!existing.has(name)) {
+        existing.add(name);
+        return name;
+    }
+    let suffix = 2;
+    while (existing.has(`${name}-${suffix}`)) {
+        suffix += 1;
+    }
+    const unique = `${name}-${suffix}`;
+    existing.add(unique);
+    return unique;
+}
+function resolvePath(raw, workspaceDir) {
+    const trimmed = raw.trim();
+    if (!trimmed) {
+        throw new Error("path required");
+    }
+    if (trimmed.startsWith("~") || path.isAbsolute(trimmed)) {
+        return path.normalize(resolveUserPath(trimmed));
+    }
+    return path.normalize(path.resolve(workspaceDir, trimmed));
+}
+function resolveIntervalMs(raw) {
+    const value = raw?.trim();
+    if (!value) {
+        return parseDurationMs(DEFAULT_QMD_INTERVAL, { defaultUnit: "m" });
+    }
+    try {
+        return parseDurationMs(value, { defaultUnit: "m" });
+    }
+    catch {
+        return parseDurationMs(DEFAULT_QMD_INTERVAL, { defaultUnit: "m" });
+    }
+}
+function resolveEmbedIntervalMs(raw) {
+    const value = raw?.trim();
+    if (!value) {
+        return parseDurationMs(DEFAULT_QMD_EMBED_INTERVAL, { defaultUnit: "m" });
+    }
+    try {
+        return parseDurationMs(value, { defaultUnit: "m" });
+    }
+    catch {
+        return parseDurationMs(DEFAULT_QMD_EMBED_INTERVAL, { defaultUnit: "m" });
+    }
+}
+function resolveDebounceMs(raw) {
+    if (typeof raw === "number" && Number.isFinite(raw) && raw >= 0) {
+        return Math.floor(raw);
+    }
+    return DEFAULT_QMD_DEBOUNCE_MS;
+}
+function resolveTimeoutMs(raw, fallback) {
+    if (typeof raw === "number" && Number.isFinite(raw) && raw > 0) {
+        return Math.floor(raw);
+    }
+    return fallback;
+}
+function resolveLimits(raw) {
+    const parsed = { ...DEFAULT_QMD_LIMITS };
+    if (raw?.maxResults && raw.maxResults > 0) {
+        parsed.maxResults = Math.floor(raw.maxResults);
+    }
+    if (raw?.maxSnippetChars && raw.maxSnippetChars > 0) {
+        parsed.maxSnippetChars = Math.floor(raw.maxSnippetChars);
+    }
+    if (raw?.maxInjectedChars && raw.maxInjectedChars > 0) {
+        parsed.maxInjectedChars = Math.floor(raw.maxInjectedChars);
+    }
+    if (raw?.timeoutMs && raw.timeoutMs > 0) {
+        parsed.timeoutMs = Math.floor(raw.timeoutMs);
+    }
+    return parsed;
+}
+function resolveSessionConfig(cfg, workspaceDir) {
+    const enabled = Boolean(cfg?.enabled);
+    const exportDirRaw = cfg?.exportDir?.trim();
+    const exportDir = exportDirRaw ? resolvePath(exportDirRaw, workspaceDir) : undefined;
+    const retentionDays = cfg?.retentionDays && cfg.retentionDays > 0 ? Math.floor(cfg.retentionDays) : undefined;
+    return {
+        enabled,
+        exportDir,
+        retentionDays,
+    };
+}
+function resolveCustomPaths(rawPaths, workspaceDir, existing) {
+    if (!rawPaths?.length) {
+        return [];
+    }
+    const collections = [];
+    rawPaths.forEach((entry, index) => {
+        const trimmedPath = entry?.path?.trim();
+        if (!trimmedPath) {
+            return;
+        }
+        let resolved;
+        try {
+            resolved = resolvePath(trimmedPath, workspaceDir);
+        }
+        catch {
+            return;
+        }
+        const pattern = entry.pattern?.trim() || "**/*.md";
+        const baseName = entry.name?.trim() || `custom-${index + 1}`;
+        const name = ensureUniqueName(baseName, existing);
+        collections.push({
+            name,
+            path: resolved,
+            pattern,
+            kind: "custom",
+        });
+    });
+    return collections;
+}
+function resolveDefaultCollections(include, workspaceDir, existing) {
+    if (!include) {
+        return [];
+    }
+    const entries = [
+        { path: workspaceDir, pattern: "MEMORY.md", base: "memory-root" },
+        { path: workspaceDir, pattern: "memory.md", base: "memory-alt" },
+        { path: path.join(workspaceDir, "memory"), pattern: "**/*.md", base: "memory-dir" },
+    ];
+    return entries.map((entry) => ({
+        name: ensureUniqueName(entry.base, existing),
+        path: entry.path,
+        pattern: entry.pattern,
+        kind: "memory",
+    }));
+}
+export function resolveMemoryBackendConfig(params) {
+    const backend = params.cfg.memory?.backend ?? DEFAULT_BACKEND;
+    const citations = params.cfg.memory?.citations ?? DEFAULT_CITATIONS;
+    if (backend !== "qmd") {
+        return { backend: "builtin", citations };
+    }
+    const workspaceDir = resolveAgentWorkspaceDir(params.cfg, params.agentId);
+    const qmdCfg = params.cfg.memory?.qmd;
+    const includeDefaultMemory = qmdCfg?.includeDefaultMemory !== false;
+    const nameSet = new Set();
+    const collections = [
+        ...resolveDefaultCollections(includeDefaultMemory, workspaceDir, nameSet),
+        ...resolveCustomPaths(qmdCfg?.paths, workspaceDir, nameSet),
+    ];
+    const rawCommand = qmdCfg?.command?.trim() || "qmd";
+    const parsedCommand = splitShellArgs(rawCommand);
+    const command = parsedCommand?.[0] || rawCommand.split(/\s+/)[0] || "qmd";
+    const resolved = {
+        command,
+        collections,
+        includeDefaultMemory,
+        sessions: resolveSessionConfig(qmdCfg?.sessions, workspaceDir),
+        update: {
+            intervalMs: resolveIntervalMs(qmdCfg?.update?.interval),
+            debounceMs: resolveDebounceMs(qmdCfg?.update?.debounceMs),
+            onBoot: qmdCfg?.update?.onBoot !== false,
+            waitForBootSync: qmdCfg?.update?.waitForBootSync === true,
+            embedIntervalMs: resolveEmbedIntervalMs(qmdCfg?.update?.embedInterval),
+            commandTimeoutMs: resolveTimeoutMs(qmdCfg?.update?.commandTimeoutMs, DEFAULT_QMD_COMMAND_TIMEOUT_MS),
+            updateTimeoutMs: resolveTimeoutMs(qmdCfg?.update?.updateTimeoutMs, DEFAULT_QMD_UPDATE_TIMEOUT_MS),
+            embedTimeoutMs: resolveTimeoutMs(qmdCfg?.update?.embedTimeoutMs, DEFAULT_QMD_EMBED_TIMEOUT_MS),
+        },
+        limits: resolveLimits(qmdCfg?.limits),
+        scope: qmdCfg?.scope ?? DEFAULT_QMD_SCOPE,
+    };
+    return {
+        backend: "qmd",
+        citations,
+        qmd: resolved,
+    };
+}

package/dist/memory/batch-voyage.js

@@ -0,0 +1,277 @@
+import { createInterface } from "node:readline";
+import { Readable } from "node:stream";
+import { retryAsync } from "../infra/retry.js";
+import { hashText, runWithConcurrency } from "./internal.js";
+export const VOYAGE_BATCH_ENDPOINT = "/v1/embeddings";
+const VOYAGE_BATCH_COMPLETION_WINDOW = "12h";
+const VOYAGE_BATCH_MAX_REQUESTS = 50000;
+function getVoyageBaseUrl(client) {
+    return client.baseUrl?.replace(/\/$/, "") ?? "";
+}
+function getVoyageHeaders(client, params) {
+    const headers = client.headers ? { ...client.headers } : {};
+    if (params.json) {
+        if (!headers["Content-Type"] && !headers["content-type"]) {
+            headers["Content-Type"] = "application/json";
+        }
+    }
+    else {
+        delete headers["Content-Type"];
+        delete headers["content-type"];
+    }
+    return headers;
+}
+function splitVoyageBatchRequests(requests) {
+    if (requests.length <= VOYAGE_BATCH_MAX_REQUESTS) {
+        return [requests];
+    }
+    const groups = [];
+    for (let i = 0; i < requests.length; i += VOYAGE_BATCH_MAX_REQUESTS) {
+        groups.push(requests.slice(i, i + VOYAGE_BATCH_MAX_REQUESTS));
+    }
+    return groups;
+}
+async function submitVoyageBatch(params) {
+    const baseUrl = getVoyageBaseUrl(params.client);
+    const jsonl = params.requests.map((request) => JSON.stringify(request)).join("\n");
+    const form = new FormData();
+    form.append("purpose", "batch");
+    form.append("file", new Blob([jsonl], { type: "application/jsonl" }), `memory-embeddings.${hashText(String(Date.now()))}.jsonl`);
+    // 1. Upload file using Voyage Files API
+    const fileRes = await fetch(`${baseUrl}/files`, {
+        method: "POST",
+        headers: getVoyageHeaders(params.client, { json: false }),
+        body: form,
+    });
+    if (!fileRes.ok) {
+        const text = await fileRes.text();
+        throw new Error(`voyage batch file upload failed: ${fileRes.status} ${text}`);
+    }
+    const filePayload = (await fileRes.json());
+    if (!filePayload.id) {
+        throw new Error("voyage batch file upload failed: missing file id");
+    }
+    // 2. Create batch job using Voyage Batches API
+    const batchRes = await retryAsync(async () => {
+        const res = await fetch(`${baseUrl}/batches`, {
+            method: "POST",
+            headers: getVoyageHeaders(params.client, { json: true }),
+            body: JSON.stringify({
+                input_file_id: filePayload.id,
+                endpoint: VOYAGE_BATCH_ENDPOINT,
+                completion_window: VOYAGE_BATCH_COMPLETION_WINDOW,
+                request_params: {
+                    model: params.client.model,
+                    input_type: "document",
+                },
+                metadata: {
+                    source: "clawdbot-memory",
+                    agent: params.agentId,
+                },
+            }),
+        });
+        if (!res.ok) {
+            const text = await res.text();
+            const err = new Error(`voyage batch create failed: ${res.status} ${text}`);
+            err.status = res.status;
+            throw err;
+        }
+        return res;
+    }, {
+        attempts: 3,
+        minDelayMs: 300,
+        maxDelayMs: 2000,
+        jitter: 0.2,
+        shouldRetry: (err) => {
+            const status = err.status;
+            return status === 429 || (typeof status === "number" && status >= 500);
+        },
+    });
+    return (await batchRes.json());
+}
+async function fetchVoyageBatchStatus(params) {
+    const baseUrl = getVoyageBaseUrl(params.client);
+    const res = await fetch(`${baseUrl}/batches/${params.batchId}`, {
+        headers: getVoyageHeaders(params.client, { json: true }),
+    });
+    if (!res.ok) {
+        const text = await res.text();
+        throw new Error(`voyage batch status failed: ${res.status} ${text}`);
+    }
+    return (await res.json());
+}
+async function readVoyageBatchError(params) {
+    try {
+        const baseUrl = getVoyageBaseUrl(params.client);
+        const res = await fetch(`${baseUrl}/files/${params.errorFileId}/content`, {
+            headers: getVoyageHeaders(params.client, { json: true }),
+        });
+        if (!res.ok) {
+            const text = await res.text();
+            throw new Error(`voyage batch error file content failed: ${res.status} ${text}`);
+        }
+        const text = await res.text();
+        if (!text.trim()) {
+            return undefined;
+        }
+        const lines = text
+            .split("\n")
+            .map((line) => line.trim())
+            .filter(Boolean)
+            .map((line) => JSON.parse(line));
+        const first = lines.find((line) => line.error?.message || line.response?.body?.error);
+        const message = first?.error?.message ??
+            (typeof first?.response?.body?.error?.message === "string"
+                ? first?.response?.body?.error?.message
+                : undefined);
+        return message;
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return message ? `error file unavailable: ${message}` : undefined;
+    }
+}
+async function waitForVoyageBatch(params) {
+    const start = Date.now();
+    let current = params.initial;
+    while (true) {
+        const status = current ??
+            (await fetchVoyageBatchStatus({
+                client: params.client,
+                batchId: params.batchId,
+            }));
+        const state = status.status ?? "unknown";
+        if (state === "completed") {
+            if (!status.output_file_id) {
+                throw new Error(`voyage batch ${params.batchId} completed without output file`);
+            }
+            return {
+                outputFileId: status.output_file_id,
+                errorFileId: status.error_file_id ?? undefined,
+            };
+        }
+        if (["failed", "expired", "cancelled", "canceled"].includes(state)) {
+            const detail = status.error_file_id
+                ? await readVoyageBatchError({ client: params.client, errorFileId: status.error_file_id })
+                : undefined;
+            const suffix = detail ? `: ${detail}` : "";
+            throw new Error(`voyage batch ${params.batchId} ${state}${suffix}`);
+        }
+        if (!params.wait) {
+            throw new Error(`voyage batch ${params.batchId} still ${state}; wait disabled`);
+        }
+        if (Date.now() - start > params.timeoutMs) {
+            throw new Error(`voyage batch ${params.batchId} timed out after ${params.timeoutMs}ms`);
+        }
+        params.debug?.(`voyage batch ${params.batchId} ${state}; waiting ${params.pollIntervalMs}ms`);
+        await new Promise((resolve) => setTimeout(resolve, params.pollIntervalMs));
+        current = undefined;
+    }
+}
+export async function runVoyageEmbeddingBatches(params) {
+    if (params.requests.length === 0) {
+        return new Map();
+    }
+    const groups = splitVoyageBatchRequests(params.requests);
+    const byCustomId = new Map();
+    const tasks = groups.map((group, groupIndex) => async () => {
+        const batchInfo = await submitVoyageBatch({
+            client: params.client,
+            requests: group,
+            agentId: params.agentId,
+        });
+        if (!batchInfo.id) {
+            throw new Error("voyage batch create failed: missing batch id");
+        }
+        params.debug?.("memory embeddings: voyage batch created", {
+            batchId: batchInfo.id,
+            status: batchInfo.status,
+            group: groupIndex + 1,
+            groups: groups.length,
+            requests: group.length,
+        });
+        if (!params.wait && batchInfo.status !== "completed") {
+            throw new Error(`voyage batch ${batchInfo.id} submitted; enable remote.batch.wait to await completion`);
+        }
+        const completed = batchInfo.status === "completed"
+            ? {
+                outputFileId: batchInfo.output_file_id ?? "",
+                errorFileId: batchInfo.error_file_id ?? undefined,
+            }
+            : await waitForVoyageBatch({
+                client: params.client,
+                batchId: batchInfo.id,
+                wait: params.wait,
+                pollIntervalMs: params.pollIntervalMs,
+                timeoutMs: params.timeoutMs,
+                debug: params.debug,
+                initial: batchInfo,
+            });
+        if (!completed.outputFileId) {
+            throw new Error(`voyage batch ${batchInfo.id} completed without output file`);
+        }
+        const baseUrl = getVoyageBaseUrl(params.client);
+        const contentRes = await fetch(`${baseUrl}/files/${completed.outputFileId}/content`, {
+            headers: getVoyageHeaders(params.client, { json: true }),
+        });
+        if (!contentRes.ok) {
+            const text = await contentRes.text();
+            throw new Error(`voyage batch file content failed: ${contentRes.status} ${text}`);
+        }
+        const errors = [];
+        const remaining = new Set(group.map((request) => request.custom_id));
+        if (contentRes.body) {
+            const reader = createInterface({
+                input: Readable.fromWeb(contentRes.body),
+                terminal: false,
+            });
+            for await (const rawLine of reader) {
+                if (!rawLine.trim()) {
+                    continue;
+                }
+                const line = JSON.parse(rawLine);
+                const customId = line.custom_id;
+                if (!customId) {
+                    continue;
+                }
+                remaining.delete(customId);
+                if (line.error?.message) {
+                    errors.push(`${customId}: ${line.error.message}`);
+                    continue;
+                }
+                const response = line.response;
+                const statusCode = response?.status_code ?? 0;
+                if (statusCode >= 400) {
+                    const message = response?.body?.error?.message ??
+                        (typeof response?.body === "string" ? response.body : undefined) ??
+                        "unknown error";
+                    errors.push(`${customId}: ${message}`);
+                    continue;
+                }
+                const data = response?.body?.data ?? [];
+                const embedding = data[0]?.embedding ?? [];
+                if (embedding.length === 0) {
+                    errors.push(`${customId}: empty embedding`);
+                    continue;
+                }
+                byCustomId.set(customId, embedding);
+            }
+        }
+        if (errors.length > 0) {
+            throw new Error(`voyage batch ${batchInfo.id} failed: ${errors.join("; ")}`);
+        }
+        if (remaining.size > 0) {
+            throw new Error(`voyage batch ${batchInfo.id} missing ${remaining.size} embedding responses`);
+        }
+    });
+    params.debug?.("memory embeddings: voyage batch submit", {
+        requests: params.requests.length,
+        groups: groups.length,
+        wait: params.wait,
+        concurrency: params.concurrency,
+        pollIntervalMs: params.pollIntervalMs,
+        timeoutMs: params.timeoutMs,
+    });
+    await runWithConcurrency(tasks, params.concurrency);
+    return byCustomId;
+}

package/dist/memory/embeddings-voyage.js

@@ -0,0 +1,75 @@
+import { requireApiKey, resolveApiKeyForProvider } from "../agents/model-auth.js";
+export const DEFAULT_VOYAGE_EMBEDDING_MODEL = "voyage-4-large";
+const DEFAULT_VOYAGE_BASE_URL = "https://api.voyageai.com/v1";
+export function normalizeVoyageModel(model) {
+    const trimmed = model.trim();
+    if (!trimmed) {
+        return DEFAULT_VOYAGE_EMBEDDING_MODEL;
+    }
+    if (trimmed.startsWith("voyage/")) {
+        return trimmed.slice("voyage/".length);
+    }
+    return trimmed;
+}
+export async function createVoyageEmbeddingProvider(options) {
+    const client = await resolveVoyageEmbeddingClient(options);
+    const url = `${client.baseUrl.replace(/\/$/, "")}/embeddings`;
+    const embed = async (input, input_type) => {
+        if (input.length === 0) {
+            return [];
+        }
+        const body = {
+            model: client.model,
+            input,
+        };
+        if (input_type) {
+            body.input_type = input_type;
+        }
+        const res = await fetch(url, {
+            method: "POST",
+            headers: client.headers,
+            body: JSON.stringify(body),
+        });
+        if (!res.ok) {
+            const text = await res.text();
+            throw new Error(`voyage embeddings failed: ${res.status} ${text}`);
+        }
+        const payload = (await res.json());
+        const data = payload.data ?? [];
+        return data.map((entry) => entry.embedding ?? []);
+    };
+    return {
+        provider: {
+            id: "voyage",
+            model: client.model,
+            embedQuery: async (text) => {
+                const [vec] = await embed([text], "query");
+                return vec ?? [];
+            },
+            embedBatch: async (texts) => embed(texts, "document"),
+        },
+        client,
+    };
+}
+export async function resolveVoyageEmbeddingClient(options) {
+    const remote = options.remote;
+    const remoteApiKey = remote?.apiKey?.trim();
+    const remoteBaseUrl = remote?.baseUrl?.trim();
+    const apiKey = remoteApiKey
+        ? remoteApiKey
+        : requireApiKey(await resolveApiKeyForProvider({
+            provider: "voyage",
+            cfg: options.config,
+            agentDir: options.agentDir,
+        }), "voyage");
+    const providerConfig = options.config.models?.providers?.voyage;
+    const baseUrl = remoteBaseUrl || providerConfig?.baseUrl?.trim() || DEFAULT_VOYAGE_BASE_URL;
+    const headerOverrides = Object.assign({}, providerConfig?.headers, remote?.headers);
+    const headers = {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey}`,
+        ...headerOverrides,
+    };
+    const model = normalizeVoyageModel(options.model);
+    return { baseUrl, headers, model };
+}

package/dist/memory/embeddings.js

@@ -1,15 +1,27 @@
 import fsSync from "node:fs";
+import { formatErrorMessage } from "../infra/errors.js";
 import { resolveUserPath } from "../utils.js";
 import { createGeminiEmbeddingProvider } from "./embeddings-gemini.js";
 import { createOpenAiEmbeddingProvider } from "./embeddings-openai.js";
+import { createVoyageEmbeddingProvider } from "./embeddings-voyage.js";
 import { importNodeLlamaCpp } from "./node-llama.js";
+function sanitizeAndNormalizeEmbedding(vec) {
+    const sanitized = vec.map((value) => (Number.isFinite(value) ? value : 0));
+    const magnitude = Math.sqrt(sanitized.reduce((sum, value) => sum + value * value, 0));
+    if (magnitude < 1e-10) {
+        return sanitized;
+    }
+    return sanitized.map((value) => value / magnitude);
+}
 const DEFAULT_LOCAL_MODEL = "hf:ggml-org/embeddinggemma-300M-GGUF/embeddinggemma-300M-Q8_0.gguf";
 function canAutoSelectLocal(options) {
     const modelPath = options.local?.modelPath?.trim();
-    if (!modelPath)
+    if (!modelPath) {
         return false;
-    if (/^(hf:|https?:)/i.test(modelPath))
+    }
+    if (/^(hf:|https?:)/i.test(modelPath)) {
         return false;
+    }
     const resolved = resolveUserPath(modelPath);
     try {
         return fsSync.statSync(resolved).isFile();
@@ -19,7 +31,7 @@ function canAutoSelectLocal(options) {
     }
 }
 function isMissingApiKeyError(err) {
-    const message = formatError(err);
+    const message = formatErrorMessage(err);
     return message.includes("No API key found for provider");
 }
 async function createLocalEmbeddingProvider(options) {
@@ -49,13 +61,13 @@ async function createLocalEmbeddingProvider(options) {
         embedQuery: async (text) => {
             const ctx = await ensureContext();
             const embedding = await ctx.getEmbeddingFor(text);
-            return Array.from(embedding.vector);
+            return sanitizeAndNormalizeEmbedding(Array.from(embedding.vector));
         },
         embedBatch: async (texts) => {
             const ctx = await ensureContext();
             const embeddings = await Promise.all(texts.map(async (text) => {
                 const embedding = await ctx.getEmbeddingFor(text);
-                return Array.from(embedding.vector);
+                return sanitizeAndNormalizeEmbedding(Array.from(embedding.vector));
             }));
             return embeddings;
         },
@@ -73,10 +85,14 @@ export async function createEmbeddingProvider(options) {
             const { provider, client } = await createGeminiEmbeddingProvider(options);
             return { provider, gemini: client };
         }
+        if (id === "voyage") {
+            const { provider, client } = await createVoyageEmbeddingProvider(options);
+            return { provider, voyage: client };
+        }
         const { provider, client } = await createOpenAiEmbeddingProvider(options);
         return { provider, openAi: client };
     };
-    const formatPrimaryError = (err, provider) => provider === "local" ? formatLocalSetupError(err) : formatError(err);
+    const formatPrimaryError = (err, provider) => provider === "local" ? formatLocalSetupError(err) : formatErrorMessage(err);
     if (requestedProvider === "auto") {
         const missingKeyErrors = [];
         let localError = null;
@@ -89,7 +105,7 @@ export async function createEmbeddingProvider(options) {
                 localError = formatLocalSetupError(err);
             }
         }
-        for (const provider of ["openai", "gemini"]) {
+        for (const provider of ["openai", "gemini", "voyage"]) {
             try {
                 const result = await createProvider(provider);
                 return { ...result, requestedProvider };
@@ -100,7 +116,7 @@ export async function createEmbeddingProvider(options) {
                     missingKeyErrors.push(message);
                     continue;
                 }
-                throw new Error(message);
+                throw new Error(message, { cause: err });
             }
         }
         const details = [...missingKeyErrors, localError].filter(Boolean);
@@ -126,17 +142,12 @@ export async function createEmbeddingProvider(options) {
                 };
             }
             catch (fallbackErr) {
-                throw new Error(`${reason}\n\nFallback to ${fallback} failed: ${formatError(fallbackErr)}`);
+                throw new Error(`${reason}\n\nFallback to ${fallback} failed: ${formatErrorMessage(fallbackErr)}`, { cause: fallbackErr });
             }
         }
-        throw new Error(reason);
+        throw new Error(reason, { cause: primaryErr });
     }
 }
-function formatError(err) {
-    if (err instanceof Error)
-        return err.message;
-    return String(err);
-}
 function isNodeLlamaCppMissing(err) {
     if (!(err instanceof Error))
         return false;
@@ -147,7 +158,7 @@ function isNodeLlamaCppMissing(err) {
     return false;
 }
 function formatLocalSetupError(err) {
-    const detail = formatError(err);
+    const detail = formatErrorMessage(err);
     const missing = isNodeLlamaCppMissing(err);
     return [
         "Local embeddings unavailable.",
@@ -160,10 +171,11 @@ function formatLocalSetupError(err) {
         "To enable local embeddings:",
         "1) Use Node 22 LTS (recommended for installs/updates)",
         missing
-            ? "2) Reinstall Moltbot (this should install node-llama-cpp): npm i -g poolbot@latest"
+            ? "2) Reinstall Poolbot (this should install node-llama-cpp): npm i -g poolbot@latest"
             : null,
         "3) If you use pnpm: pnpm approve-builds (select node-llama-cpp), then pnpm rebuild node-llama-cpp",
         'Or set agents.defaults.memorySearch.provider = "openai" (remote).',
+        'Or set agents.defaults.memorySearch.provider = "voyage" (remote).',
     ]
         .filter(Boolean)
         .join("\n");