@sigrun/recall 0.0.0-stage → 0.1.3

package/CHANGELOG.md

@@ -0,0 +1,42 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.1.3] - 2026-11-03
+
+### Added
+
+- The search route accepts `?exclude=<conversationId>` so callers can reproduce auto-recall's exclusion of the current conversation (eval fidelity).
+- The eval harness (`scripts/recall-eval.ts`) supports a per-pair `exclude` field with client-side filtering, and over-fetches when excluding so filtered hits don't consume the top-k window.
+
+### Fixed
+
+- (from polish wave 1, 0.1.2) The shutdown drain is bounded and its race timer clears on fast settles.
+
+## [0.1.2] - Unreleased
+
+### Fixed
+
+- Bound the shutdown drain: each round races `Promise.allSettled(pending)` against a timer for the remaining budget, so a capture whose embedding fetch never settles can no longer hang `harnessShutdown` past the 30s deadline; the database still closes.
+
+## [0.1.1] - Unreleased
+
+### Fixed
+
+- Version bump only: 0.1.0 was occupied by a registry-side staging artifact and is permanently unavailable; this is the initial published release.
+
+## [0.1.0] - Unreleased
+
+### Changed (release pinning)
+
+- `@sigrun/shared` is pinned as a peer at `0.5.0` (runtime VALUE imports — `accessOf` — ride the peer, with the dev `file:` link to core's workspace, the ext-gateway family posture).
+- `@sigrun/sigrun` stays the development `file:../sigrun` link (types-only consumption; core 0.5.0 carries C1 on the registry — but this repo never imports it at runtime, so no pin is needed for installs).
+
+### Added
+
+- Idempotent capture of conversation turns, tool calls/results, and whole large tool results with redacted porter/trigram indexes.
+- Live audience and confidentiality enforcement, optional semantic embeddings, and bounded recency-ranked search.
+- Replay-safe `recall_search`/`recall_open` tools and byte-stable request-only automatic recall.
+- Rotating, resumable backfill cron task plus user search and admin sweep routes.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Michael MacLeod
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,46 @@
-# Temporary Holding Version
+# @sigrun/recall
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Cross-conversation recall for [sigrun](https://github.com/sigrun-ai/sigrun), as an optional pi-durable extension.
+
+Recall indexes conversation turns, tool calls/results, and complete large tool results in an extension-scoped SQLite database. Settled runs are captured incrementally; a ten-minute backfill job also visits imported or interrupted conversations. Search combines porter stemming, trigram substring matching, optional embeddings, and recency. The model can use `recall_search` and `recall_open`; automatic recall adds bounded, clearly marked reference material to new user messages.
+
+## Settings and secrets
+
+Extension settings support `externalizeBytes` (default `24576`) and an optional `embedding` object:
+
+```json
+{
+  "externalizeBytes": 24576,
+  "embedding": {
+    "url": "https://example.invalid/embed",
+    "model": "embed-model",
+    "local": false,
+    "timeoutMs": 800
+  }
+}
+```
+
+The optional `embedding-api-key` secret authorizes the `[OI]`-compatible embeddings endpoint. Embeddings are sent in batches and only when configured; failures leave lexical search available. Per-user settings support `autoRecall` (default `true`) and `localProviders` (default `[]`).
+
+## Access and confidentiality
+
+Items are `normal` or `local-only`. Local-only material reaches only models whose provider is in the item owner's `localProviders`; an absent model or unknown owner fails closed. Recall also re-checks live conversation sharing for every reader of the calling conversation: material shared later becomes visible, and revoked sharing stops matching immediately. Internal conversations are never indexed or recalled. Displaying local-only material taints subsequent capture in the calling conversation.
+
+Auto-recall excludes the current conversation and job runs; explicit `recall_search` can include both. Stored injection blocks are reused byte-for-byte where policy allows and are kept for the conversation's life (they are small; v1 does not prune them).
+
+## Large results and reading
+
+Complete tool results larger than `externalizeBytes` are stored whole under `artifacts/`, indexed in bounded passages, and replaced in model output by a head, outline, and handle. Truncated or spilled shell output is not externalized because the hook no longer has the complete result; complete shell output over the threshold is externalized. `recall_open` accepts `{offset, length}` for byte-based artifact slices; the spec's `section` option is deferred.
+
+Trigram search cannot match CJK substrings shorter than three characters. Use at least three characters for those queries.
+
+## Development and uninstall
+
+```sh
+npm install
+npm test
+npm run typecheck
+npm run build
+```
+
+`dist/` is committed by design for git-source installs. Tests use synthetic data and do not contact external services. To uninstall recall data, remove the extension and delete `<data>/recall.db` plus `<data>/artifacts/`.

package/dist/artifacts.d.ts

@@ -0,0 +1,32 @@
+import type { ToolExecutionResult, ToolHookCall } from "@earendil-works/pi-durable";
+import type { RecallDb } from "./db.js";
+export interface ArtifactStore {
+    put(text: string, meta: {
+        title?: string;
+        url?: string;
+        conversationId: number;
+        owner: string | null;
+        at: number;
+    }): {
+        handle: string;
+        bytes: number;
+    };
+    read(handle: string, offset: number, length: number): string | undefined;
+}
+/** Store whole tool results by content hash and index their searchable text. */
+export declare function createArtifactStore(db: RecallDb, dir: string): ArtifactStore;
+/** Return markdown headings, or fixed-size part markers for unheaded text. */
+export declare function outline(text: string): {
+    title: string;
+    offset: number;
+}[];
+/** Render the retained head and bounded navigation stub for an artifact. */
+export declare function renderStub(text: string, handle: string, headBytes: 6144): string;
+/** Replace only large, complete top-level tool output with an artifact stub. */
+export declare function externalize(result: ToolExecutionResult, call: ToolHookCall, deps: {
+    store: ArtifactStore;
+    thresholdBytes: number;
+    conversationId: number;
+    owner: string | null;
+    now: number;
+}): ToolExecutionResult | undefined;

package/dist/artifacts.js

@@ -0,0 +1,137 @@
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { redact } from "./redact.js";
+const ARTIFACT_PASSAGE_SIZE = 2000;
+const SYNTHETIC_OUTLINE_SIZE = 4096;
+/** Store whole tool results by content hash and index their searchable text. */
+export function createArtifactStore(db, dir) {
+    function pathForHandle(handle) {
+        if (!/^a:[0-9a-f]{16}$/.test(handle))
+            return undefined;
+        const hash = db.artifactHash(handle);
+        return hash === undefined ? undefined : join(dir, `${hash}.txt`);
+    }
+    return {
+        put(text, meta) {
+            const hash = createHash("sha256").update(text).digest("hex");
+            const handle = `a:${hash.slice(0, 16)}`;
+            const path = join(dir, `${hash}.txt`);
+            if (!existsSync(path)) {
+                mkdirSync(dir, { recursive: true });
+                const temporary = `${path}.${process.pid}.tmp`;
+                writeFileSync(temporary, text, "utf8");
+                renameSync(temporary, path);
+            }
+            db.putArtifact(hash, Buffer.byteLength(text), {
+                title: meta.title,
+                url: meta.url,
+                createdAt: meta.at,
+            });
+            const buffer = Buffer.from(text, "utf8");
+            for (let offset = 0; offset < buffer.length; offset += ARTIFACT_PASSAGE_SIZE) {
+                const bytes = buffer.subarray(offset, offset + ARTIFACT_PASSAGE_SIZE);
+                const passage = bytes.toString("utf8");
+                db.insertItem({
+                    conversationId: meta.conversationId,
+                    owner: meta.owner,
+                    kind: "artifact",
+                    entryId: null,
+                    messageIndex: null,
+                    blockIndex: 0,
+                    offset,
+                    length: bytes.length,
+                    artifact: handle,
+                    job: false,
+                    cls: "normal",
+                    at: meta.at,
+                    title: meta.title ?? null,
+                }, redact(passage));
+            }
+            return { handle, bytes: Buffer.byteLength(text) };
+        },
+        read(handle, offset, length) {
+            const path = pathForHandle(handle);
+            if (path === undefined || !existsSync(path))
+                return undefined;
+            const buffer = readFileSync(path);
+            let start = Math.min(offset, buffer.length);
+            let end = Math.min(offset + length, buffer.length);
+            while (start > 0 && start < buffer.length && (buffer[start] & 0xc0) === 0x80)
+                start -= 1;
+            while (end > start && end < buffer.length && (buffer[end] & 0xc0) === 0x80)
+                end -= 1;
+            return buffer.subarray(start, end).toString("utf8");
+        },
+    };
+}
+/** Return markdown headings, or fixed-size part markers for unheaded text. */
+export function outline(text) {
+    const headings = [];
+    for (const match of text.matchAll(/^#{1,6} (.+)$/gm)) {
+        headings.push({
+            title: match[1],
+            offset: Buffer.byteLength(text.slice(0, match.index)),
+        });
+    }
+    if (headings.length > 0)
+        return headings;
+    const parts = [];
+    for (let offset = 0; offset < Buffer.byteLength(text); offset += SYNTHETIC_OUTLINE_SIZE) {
+        parts.push({ title: `part ${parts.length + 1}`, offset });
+    }
+    return parts;
+}
+/** Render the retained head and bounded navigation stub for an artifact. */
+export function renderStub(text, handle, headBytes) {
+    const buffer = Buffer.from(text, "utf8");
+    const bytes = buffer.length;
+    let headBuffer = buffer.subarray(0, headBytes);
+    const lastLine = headBuffer.lastIndexOf(0x0a);
+    if (lastLine >= 0)
+        headBuffer = headBuffer.subarray(0, lastLine + 1);
+    const head = headBuffer.toString("utf8");
+    const lines = outline(text)
+        .slice(0, 40)
+        .map(({ title, offset }) => `- ${title} (offset ${offset})`);
+    return `${head}\n\n[recall: full result stored as ${handle}, ${bytes} bytes. Outline:]\n${lines.join("\n")}\nRead more with recall_open("${handle}", {offset}).`;
+}
+function textOf(result) {
+    return (result.output ?? [])
+        .filter((part) => part.type === "text")
+        .map((part) => part.text)
+        .join("\n");
+}
+function alreadyPartial(result) {
+    const structured = result.structuredOutput;
+    if (typeof structured !== "object" || structured === null || Array.isArray(structured)) {
+        return false;
+    }
+    const record = structured;
+    return record.truncated === true || record.fullOutputPath !== undefined;
+}
+/** Replace only large, complete top-level tool output with an artifact stub. */
+export function externalize(result, call, deps) {
+    if (call.parent !== undefined ||
+        result.isError === true ||
+        alreadyPartial(result) ||
+        result.output === undefined) {
+        return undefined;
+    }
+    const text = textOf(result);
+    if (Buffer.byteLength(text) <= deps.thresholdBytes)
+        return undefined;
+    const url = typeof call.arguments.url === "string" ? call.arguments.url : undefined;
+    const saved = deps.store.put(text, {
+        title: call.name,
+        url,
+        conversationId: deps.conversationId,
+        owner: deps.owner,
+        at: deps.now,
+    });
+    const nonText = result.output.filter((part) => part.type !== "text");
+    return {
+        ...result,
+        output: [...nonText, { type: "text", text: renderStub(text, saved.handle, 6144) }],
+    };
+}

package/dist/audience.d.ts

@@ -0,0 +1,11 @@
+import { type Sharing } from "@sigrun/shared/access";
+interface ConversationAccess {
+    readonly owner?: string;
+    readonly sharing?: Sharing;
+}
+/**
+ * Return whether an item from `item` may surface to every ordinary reader of
+ * `current`. Superuser access is deliberately not part of this decision.
+ */
+export declare function audienceCovers(current: ConversationAccess, item: ConversationAccess): boolean;
+export {};

package/dist/audience.js

@@ -0,0 +1,36 @@
+import { accessOf } from "@sigrun/shared/access";
+/**
+ * Return whether an item from `item` may surface to every ordinary reader of
+ * `current`. Superuser access is deliberately not part of this decision.
+ */
+export function audienceCovers(current, item) {
+    // Ownerless items are readable by everyone.
+    if (item.owner === undefined)
+        return true;
+    if (current.sharing?.scope === "people") {
+        const users = new Set(current.sharing.users);
+        if (current.owner !== undefined)
+            users.add(current.owner);
+        for (const user of users) {
+            if (accessOf({ user }, item) === "none")
+                return false;
+        }
+        // An ownerless people current with no users has a vacuous user set:
+        // only its groups constrain which items may surface.
+        // This empty-reader-set behavior is the mechanical table outcome.
+        return (current.sharing.groups ?? []).every((group) => item.sharing?.scope === "household" ||
+            (item.sharing?.scope === "people" &&
+                item.sharing.groups?.includes(group) === true));
+    }
+    if (current.sharing?.scope === "household") {
+        // Level is deliberately ignored: household grants every identified user
+        // read access; its level only widens that access to write.
+        return item.sharing?.scope === "household";
+    }
+    if (current.owner === undefined) {
+        // A genuinely unshared, ownerless current is readable by everyone.
+        return item.sharing?.scope === "household";
+    }
+    // Private, including an absent sharing grant: only the owner reads current.
+    return accessOf({ user: current.owner }, item) !== "none";
+}

package/dist/backfill.d.ts

@@ -0,0 +1,20 @@
+import { type AnyTask } from "@earendil-works/pi-durable";
+import type { SigrunHost } from "@sigrun/sigrun/extension";
+import type { captureConversation } from "./capture.js";
+import type { RecallDb } from "./db.js";
+export declare const BACKFILL_TASK_NAME = "recall.backfill";
+export interface BackfillDeps {
+    host: SigrunHost;
+    capture: typeof captureConversation;
+    db: RecallDb;
+    vectors?: () => Promise<void>;
+    now?: () => number;
+    entryBudget?: number;
+}
+/** Sweep conversations in rotating id order under a bounded entry/time budget. */
+export declare function runSweep(deps: BackfillDeps): Promise<{
+    indexed: number;
+    sweepAfter: number;
+}>;
+/** Register the one-phase cron backfill task. */
+export declare function createBackfillTask(deps: BackfillDeps | (() => BackfillDeps)): AnyTask;

package/dist/backfill.js

@@ -0,0 +1,64 @@
+import { defineTask } from "@earendil-works/pi-durable";
+export const BACKFILL_TASK_NAME = "recall.backfill";
+/** Sweep conversations in rotating id order under a bounded entry/time budget. */
+export async function runSweep(deps) {
+    const started = (deps.now ?? Date.now)();
+    const [archived, active] = await Promise.all([
+        deps.host.conversations.list({ archived: true }),
+        deps.host.conversations.list({ archived: false }),
+    ]);
+    const ids = [...archived, ...active].map(({ id }) => Number(id)).sort((a, b) => a - b);
+    let sweepAfter = Number(deps.db.state("sweepAfter") ?? 0);
+    const start = ids.findIndex((id) => id > sweepAfter);
+    const ordered = start < 0 ? ids : [...ids.slice(start), ...ids.slice(0, start)];
+    let indexed = 0;
+    let entries = 0;
+    const entryBudget = deps.entryBudget ?? 2000;
+    for (const id of ordered) {
+        if ((deps.now ?? Date.now)() - started >= 20_000 || entries >= entryBudget)
+            break;
+        try {
+            const result = await deps.capture({
+                db: deps.db,
+                meta: (conversationId) => deps.host.conversations.meta(conversationId),
+                now: deps.now ?? Date.now,
+            }, id, async (query, limit, cursor) => {
+                const page = await deps.host.conversations.entries(id, query, limit, cursor);
+                entries += page.items.length;
+                return page;
+            });
+            indexed += result.indexed;
+            sweepAfter = id;
+            deps.db.setState("sweepAfter", String(id));
+        }
+        catch (error) {
+            console.error(`recall: backfill failed for conversation ${id}`, error);
+        }
+    }
+    await deps.vectors?.();
+    return { indexed, sweepAfter };
+}
+/** Register the one-phase cron backfill task. */
+export function createBackfillTask(deps) {
+    const resolve = typeof deps === "function" ? deps : () => deps;
+    return defineTask({
+        name: BACKFILL_TASK_NAME,
+        version: 1,
+        initial: () => ({ phase: "sweep" }),
+        phases: {
+            sweep: async (_task, runtime, context) => {
+                const result = await runSweep(resolve());
+                await runtime.commit(() => ({
+                    status: "terminal",
+                    outcome: { status: "completed", result },
+                }), context);
+            },
+        },
+        abort: async (_task, runtime, context) => {
+            await runtime.commit(() => ({
+                status: "terminal",
+                outcome: { status: "failed", error: { message: "aborted" } },
+            }), context);
+        },
+    });
+}

package/dist/capture.d.ts

@@ -0,0 +1,22 @@
+import type { Cursor, EntryRecord, Page } from "@earendil-works/pi-durable";
+import type { SessionMeta } from "@sigrun/shared/session-meta";
+import type { RecallDb } from "./db.js";
+import type { Embedder } from "./embed.js";
+import type { VectorIndex } from "./vectors.js";
+export interface CaptureDeps {
+    db: RecallDb;
+    meta(id: number): Promise<SessionMeta>;
+    now(): number;
+    /** Optional best-effort semantic indexing; capture never awaits embedding. */
+    embedder?: Embedder;
+    index?: VectorIndex;
+    trackEmbedding?: (work: Promise<void>) => void;
+}
+export type EntryReader = (query: {
+    minEntryId?: number;
+    order: "ascending";
+}, limit: number, cursor?: Cursor) => Promise<Page<EntryRecord, Cursor>>;
+/** Index newly settled conversation entries, resuming from the saved cursor. */
+export declare function captureConversation(deps: CaptureDeps, conversationId: number, read: EntryReader): Promise<{
+    indexed: number;
+}>;

package/dist/capture.js

@@ -0,0 +1,80 @@
+import { passagesOf } from "./passages.js";
+import { redact } from "./redact.js";
+const PAGE_SIZE = 200;
+/** Index newly settled conversation entries, resuming from the saved cursor. */
+export async function captureConversation(deps, conversationId, read) {
+    const meta = await deps.meta(conversationId);
+    if (meta.internal === true)
+        return { indexed: 0 };
+    const savedCursor = deps.db.cursor(conversationId);
+    const query = { order: "ascending" };
+    if (savedCursor !== undefined)
+        query.minEntryId = savedCursor + 1;
+    const taintFrom = deps.db.taintFrom(conversationId);
+    let indexed = 0;
+    let cursor;
+    do {
+        const page = await read(query, PAGE_SIZE, cursor);
+        const insertedForEmbedding = [];
+        for (const entry of page.items) {
+            if (entry.conversationId !== conversationId)
+                continue;
+            for (const passage of passagesOf(entry)) {
+                const inserted = deps.db.insertItem({
+                    conversationId,
+                    owner: meta.owner ?? null,
+                    kind: passage.kind,
+                    entryId: passage.entryId,
+                    messageIndex: passage.messageIndex,
+                    blockIndex: passage.blockIndex,
+                    offset: passage.offset,
+                    length: passage.length,
+                    artifact: null,
+                    job: meta.jobId !== undefined,
+                    cls: taintFrom !== undefined && passage.entryId >= taintFrom
+                        ? "local-only"
+                        : "normal",
+                    at: passage.at,
+                    title: meta.name ?? meta.autoName ?? null,
+                }, redact(passage.text));
+                if (inserted !== undefined) {
+                    indexed += 1;
+                    insertedForEmbedding.push({
+                        id: inserted,
+                        text: redact(passage.text),
+                        localOnly: taintFrom !== undefined && passage.entryId >= taintFrom,
+                    });
+                }
+            }
+        }
+        if (deps.embedder !== undefined && deps.index !== undefined) {
+            const work = embedPage(deps.embedder, deps.index, insertedForEmbedding);
+            if (deps.trackEmbedding === undefined)
+                void work;
+            else
+                deps.trackEmbedding(work);
+        }
+        const lastEntry = page.items.at(-1);
+        if (lastEntry !== undefined)
+            deps.db.setCursor(conversationId, lastEntry.id);
+        cursor = page.next;
+    } while (cursor !== undefined);
+    return { indexed };
+}
+async function embedPage(embedder, index, inserted) {
+    const candidates = inserted.filter(({ localOnly }) => !localOnly || embedder.local);
+    for (let offset = 0; offset < candidates.length; offset += 64) {
+        const batch = candidates.slice(offset, offset + 64);
+        try {
+            const vectors = await embedder.embed(batch.map(({ text }) => text));
+            for (const [indexInBatch, vector] of vectors.entries()) {
+                const candidate = batch[indexInBatch];
+                if (candidate !== undefined)
+                    index.upsert(candidate.id, vector);
+            }
+        }
+        catch (error) {
+            console.error("recall: passage embedding failed; item remains lexical-only", error);
+        }
+    }
+}

package/dist/config.d.ts

@@ -0,0 +1,18 @@
+export interface SettingsReader {
+    get(): Promise<Record<string, unknown>>;
+}
+export interface RecallSettings {
+    externalizeBytes: number;
+    embedding?: {
+        url: string;
+        model: string;
+        local: boolean;
+        timeoutMs: number;
+    };
+}
+export interface UserRecallSettings {
+    autoRecall: boolean;
+    localProviders: readonly string[];
+}
+export declare function resolveSettings(store: SettingsReader): Promise<RecallSettings>;
+export declare function resolveUserSettings(store: SettingsReader): Promise<UserRecallSettings>;

package/dist/config.js

@@ -0,0 +1,71 @@
+const DEFAULT_EXTERNALIZE_BYTES = 24_576;
+const DEFAULT_EMBEDDING_TIMEOUT_MS = 800;
+function warnInvalid(setting) {
+    console.warn(`recall: invalid ${setting} setting; using its default`);
+}
+function positiveInteger(value, fallback, setting) {
+    if (value === undefined)
+        return fallback;
+    if (typeof value === "number" && Number.isInteger(value) && value > 0)
+        return value;
+    warnInvalid(setting);
+    return fallback;
+}
+function nonEmptyString(value, setting) {
+    if (typeof value === "string" && value !== "")
+        return value;
+    warnInvalid(setting);
+    return undefined;
+}
+function embeddingSettings(value) {
+    if (value === undefined || value === null)
+        return undefined;
+    if (typeof value !== "object" || Array.isArray(value)) {
+        warnInvalid("embedding");
+        return undefined;
+    }
+    const raw = value;
+    const url = nonEmptyString(raw.url, "embedding.url");
+    const model = nonEmptyString(raw.model, "embedding.model");
+    if (url === undefined || model === undefined)
+        return undefined;
+    if (raw.local !== undefined && typeof raw.local !== "boolean") {
+        warnInvalid("embedding.local");
+    }
+    return {
+        url,
+        model,
+        local: typeof raw.local === "boolean" ? raw.local : false,
+        timeoutMs: positiveInteger(raw.timeoutMs, DEFAULT_EMBEDDING_TIMEOUT_MS, "embedding.timeoutMs"),
+    };
+}
+export async function resolveSettings(store) {
+    const raw = await store.get();
+    const settings = {
+        externalizeBytes: positiveInteger(raw.externalizeBytes, DEFAULT_EXTERNALIZE_BYTES, "externalizeBytes"),
+    };
+    const embedding = embeddingSettings(raw.embedding);
+    if (embedding !== undefined)
+        settings.embedding = embedding;
+    return settings;
+}
+export async function resolveUserSettings(store) {
+    const raw = await store.get();
+    if (raw.autoRecall !== undefined && typeof raw.autoRecall !== "boolean") {
+        warnInvalid("autoRecall");
+    }
+    let localProviders = [];
+    if (raw.localProviders !== undefined) {
+        if (Array.isArray(raw.localProviders) &&
+            raw.localProviders.every((provider) => typeof provider === "string" && provider !== "")) {
+            localProviders = [...raw.localProviders];
+        }
+        else {
+            warnInvalid("localProviders");
+        }
+    }
+    return {
+        autoRecall: typeof raw.autoRecall === "boolean" ? raw.autoRecall : true,
+        localProviders,
+    };
+}