@autorag/librarian 2.10.5 → 2.11.0

package/dist/datasource/skills/obsidian/paths.d.ts

@@ -1,27 +1,27 @@
 /**
- * Path helpers for the Obsidian (`qmd`) datasource skill.
+ * Path helpers for the Obsidian datasource.
  *
- * All AutoRAG-managed state lives under
- * `<workspaceRoot>/.autorag/datasources/obsidian/<instanceId>/`. The external
- * `qmd` CLI is pointed at isolated config/cache dirs so multiple workspaces
- * never share an index. Callers surface opaque slash-hierarchical sources of
- * the form `/obsidian/<instance-id>/chunks/<chunk-id>`.
+ * Everything AutoRAG owns for one vault lives under
+ * `<workspaceRoot>/.autorag/datasources/obsidian/<instance>/`: a MinSync workspace of its own
+ * (`minsync/`, never shared with the local-file index) and the staging record (`staging.json`)
+ * that maps staged notes back to the vault. Callers see slash-hierarchical opaque sources of
+ * the form `/obsidian/<instance>/<vault-relative note path>`.
  */
-export declare const AUTORAG_DIRNAME = ".autorag";
-export declare const DATASOURCES_DIRNAME = "datasources";
-export declare const OBSIDIAN_DATASOURCE_DIRNAME = "obsidian";
-export declare const OBSIDIAN_SOURCE_KIND: "obsidian";
-export declare function obsidianDatasourceRoot(workspaceRoot: string, instanceId: string): string;
-/** Directory passed to `QMD_CONFIG_DIR` (holds `index.yml`). */
-export declare function obsidianQmdConfigDir(workspaceRoot: string, instanceId: string): string;
-/** Directory passed to `XDG_CACHE_HOME` (holds `qmd/index.sqlite`). */
-export declare function obsidianQmdCacheDir(workspaceRoot: string, instanceId: string): string;
-export declare function obsidianSourcePath(instanceId: string, chunkId: string): string;
-export declare function parseObsidianSourcePath(source: string): {
-    readonly instanceId: string;
-    readonly chunkId: string;
-} | undefined;
-/** Strip leading and trailing ASCII dashes without a quadratic regex. */
-export declare function stripEdgeDashes(value: string): string;
-/** Sanitize an instance id into a qmd collection name. */
-export declare function toQmdCollectionName(instanceId: string): string;
+export declare const OBSIDIAN_DATASOURCE_ID = "obsidian";
+export declare const OBSIDIAN_SKILL_TYPE = "obsidian-vault";
+export declare function obsidianDatasourceDir(workspaceRoot: string, instanceId: string): string;
+/** The MinSync workspace this vault is indexed in; staged notes live in its `files/` folder. */
+export declare function obsidianMinSyncWorkspace(workspaceRoot: string, instanceId: string): string;
+/** Kept beside the MinSync workspace, outside the tree MinSync indexes. */
+export declare function obsidianStagingStatePath(workspaceRoot: string, instanceId: string): string;
+/**
+ * Escape what would change the meaning of a source segment: `%` (the escape itself), `/` (the
+ * separator, possible in an instance id), `#` (datasource sources never carry a fragment), `\`
+ * (not valid in a virtual path) and `*` (a scope glob). Everything else, spaces and non-Latin
+ * letters included, stays readable.
+ */
+export declare function encodeSourceSegment(segment: string): string;
+/** The root source of one vault: the scope that selects every note in it. */
+export declare function obsidianInstanceSource(instanceId: string): string;
+/** The source of one note, from its vault-relative path written with `/` separators. */
+export declare function obsidianNoteSource(instanceId: string, relativePath: string): string;

package/dist/datasource/skills/obsidian/skill.d.ts

@@ -1,37 +1,33 @@
 import type { RetrievalMethod } from "../../../retrieval/types.js";
 import type { DatasourceIndexOptions, DatasourceIndexResult, DatasourceSkill, DatasourceSkillDescriptor, DatasourceSkillManifest, PollingMetadata, SourceDescription } from "../../types.js";
-import { type ObsidianSearchClient } from "./methods.js";
-import type { QmdEmbedResult, QmdEnsureResult, QmdUpdateResult } from "./types.js";
-export interface ObsidianSkillClient extends ObsidianSearchClient {
-    ensureCollection(signal?: AbortSignal): Promise<QmdEnsureResult>;
-    update(signal?: AbortSignal): Promise<QmdUpdateResult>;
-    embed(signal?: AbortSignal): Promise<QmdEmbedResult>;
-}
+import { type ObsidianMinSyncOptions } from "./vault-index.js";
 export interface ObsidianSkillOptions {
     readonly datasourceId?: string;
-    readonly client?: ObsidianSkillClient;
     readonly vaultPath?: string;
-    readonly binaryPath?: string;
     readonly instanceId?: string;
     readonly instances?: readonly string[];
     readonly pollingIntervalMs?: number;
     readonly tags?: readonly string[];
     readonly lastIndexedAt?: number;
+    /** Where `.autorag/datasources/obsidian/<instance>` is kept. Required to index or search. */
     readonly workspaceRoot?: string;
-    readonly collectionName?: string;
-    readonly timeoutMs?: number;
-    readonly configPath?: string;
+    /** The install's MinSync binary, embedder and chunking, shared with the local-file index. */
+    readonly minSync?: ObsidianMinSyncOptions;
     readonly connectorOptions?: {
         readonly vaultPath?: string;
     };
 }
+/**
+ * An Obsidian vault as a datasource: its markdown notes are indexed by MinSync (BM25 and
+ * semantic) in a workspace of their own, and a note's source is its vault-relative path, so a
+ * folder is an ordinary `scope`.
+ */
 export declare class ObsidianSkill implements DatasourceSkill {
-    private readonly client;
+    private readonly vaultIndex;
     private readonly instanceId;
     private readonly instances;
     private readonly pollingIntervalMs;
     private readonly tags;
-    private readonly vaultPath;
     private lastIndexedAt;
     private lastError;
     constructor(options?: ObsidianSkillOptions);
@@ -41,5 +37,4 @@ export declare class ObsidianSkill implements DatasourceSkill {
     retrievalMethods(): readonly RetrievalMethod[];
     describeSources(): readonly SourceDescription[];
     skillManifest(): DatasourceSkillManifest;
-    private fail;
 }

package/dist/datasource/skills/obsidian/staging.d.ts

@@ -0,0 +1,50 @@
+export interface VaultNote {
+    /** Vault-relative path, NFC-normalized, `/`-separated. */
+    readonly relativePath: string;
+    readonly sourcePath: string;
+    readonly size: number;
+    /** Exact nanosecond mtime as a decimal string (it exceeds a double's integer range). */
+    readonly mtimeNs: string;
+}
+export interface VaultListing {
+    readonly notes: ReadonlyMap<string, VaultNote>;
+    /** Folders (vault-relative) that could not be read; their staged notes are kept as they were. */
+    readonly unreadableFolders: readonly string[];
+    /** Notes dropped because another note has the same NFC-normalized path. */
+    readonly collisions: readonly string[];
+}
+export declare class VaultUnavailableError extends Error {
+    readonly code: string;
+    constructor(code: string);
+}
+/**
+ * List the vault's notes. Dot-prefixed folders and files (`.obsidian`, `.trash`, `.git`),
+ * `node_modules`, and symlinks are not part of the vault's knowledge and are skipped.
+ * Throws {@link VaultUnavailableError} when the vault root itself cannot be read.
+ */
+export declare function listVaultNotes(vaultPath: string): Promise<VaultListing>;
+interface StagingEntry {
+    readonly sourcePath: string;
+    readonly size: number;
+    readonly mtimeNs: string;
+}
+export interface StagingState {
+    readonly version: 1;
+    readonly entries: Readonly<Record<string, StagingEntry>>;
+}
+export declare function loadStagingState(statePath: string): StagingState;
+export interface StageResult {
+    readonly staged: number;
+    readonly copied: number;
+    readonly removed: number;
+    /** Notes that could not be copied this time; an earlier staged copy, if any, was kept. */
+    readonly failed: readonly string[];
+}
+/**
+ * Bring `<filesRoot>` in line with the vault: copy new and changed notes, delete notes that no
+ * longer exist, and leave notes under an unreadable folder exactly as they were.
+ */
+export declare function stageNotes(filesRoot: string, statePath: string, listing: VaultListing, options?: {
+    readonly force?: boolean;
+}): StageResult;
+export {};

package/dist/datasource/skills/obsidian/vault-index.d.ts

@@ -0,0 +1,44 @@
+import type { MinSyncVectorMethodOptions } from "../../../minsync/method.js";
+import type { RetrievalResult } from "../../../retrieval/types.js";
+import type { DatasourceDiagnostic, DatasourceDiagnosticCode } from "../../types.js";
+/** The MinSync settings a vault shares with the rest of the install: binary, embedder, chunking. */
+export type ObsidianMinSyncOptions = Pick<MinSyncVectorMethodOptions, "binaryPath" | "autoInstall" | "installer" | "embedder" | "maxChunkSize">;
+export interface ObsidianVaultIndexOptions {
+    readonly instanceId: string;
+    readonly vaultPath: string | undefined;
+    readonly workspaceRoot: string | undefined;
+    readonly minSync?: ObsidianMinSyncOptions;
+}
+export type ObsidianSearchMode = "bm25" | "semantic";
+export interface ObsidianSearchOptions {
+    readonly topK?: number;
+    readonly scope?: string;
+    readonly signal?: AbortSignal;
+}
+export type VaultSyncOutcome = {
+    readonly ok: true;
+    readonly notes: number;
+    readonly diagnostics: readonly DatasourceDiagnostic[];
+} | {
+    readonly ok: false;
+    readonly code: DatasourceDiagnosticCode;
+    readonly message: string;
+};
+/**
+ * One vault, indexed by MinSync in a workspace of its own. Notes are staged under the workspace's
+ * `files/` folder (see `staging.ts`), `minsync sync` embeds and indexes them incrementally, and a
+ * query runs against that index and maps each chunk back to its note.
+ */
+export declare class ObsidianVaultIndex {
+    private readonly instanceId;
+    private readonly vaultPath;
+    private readonly workspaceRoot;
+    private readonly minSync;
+    constructor(options: ObsidianVaultIndexOptions);
+    /** Mirror the vault's notes into the MinSync workspace and sync it. Never throws except on abort. */
+    sync(signal?: AbortSignal): Promise<VaultSyncOutcome>;
+    private syncLocked;
+    /** Search the indexed vault. Rejects, with the reason, when the vault was never indexed or a sync is running. */
+    query(mode: ObsidianSearchMode, text: string, options?: ObsidianSearchOptions): Promise<RetrievalResult[]>;
+    private queryLocked;
+}

package/dist/embedding/daemon.d.ts

@@ -0,0 +1,57 @@
+/** The model `minsync serve` serves by default; callers pass another to look for that one. */
+export declare const DEFAULT_DAEMON_MODEL = "Qwen/Qwen3-Embedding-0.6B";
+export interface MinSyncDaemon {
+    /** `http://127.0.0.1:<port>`; the OpenAI route lives under `/v1`, TEI at `/embed`. */
+    readonly baseUrl: string;
+    readonly model: string;
+    readonly dimension: number;
+    readonly instance: string;
+    /** True when {@link ensureMinSyncDaemon} spawned it. */
+    readonly started: boolean;
+    readonly pid?: number;
+}
+export declare class MinSyncDaemonError extends Error {
+    constructor(message: string, options?: ErrorOptions);
+}
+export interface ProbeOptions {
+    /** User home; MinSync keeps its server state under `<home>/.cache/minsync/serve`. */
+    readonly home?: string;
+    /** Only accept a server of this model. Defaults to {@link DEFAULT_DAEMON_MODEL}. */
+    readonly model?: string;
+    readonly fetchImpl?: typeof fetch;
+}
+/**
+ * MinSync publishes `host`/`port` (and `pid`) per model instance under
+ * `~/.cache/minsync/serve/<instance>/` and removes them on a clean stop. A leftover file from a crashed
+ * server is harmless because every candidate must answer `GET /health` as a loopback `status: ok` server of
+ * the wanted model before it is used.
+ */
+export declare function minSyncServeStateRoot(home?: string): string;
+export declare function probeMinSyncDaemon(options?: ProbeOptions): Promise<MinSyncDaemon | undefined>;
+export interface EnsureDaemonOptions extends ProbeOptions {
+    /** The `minsync` executable. Required only when no daemon is running yet. */
+    readonly binaryPath: string;
+    readonly env?: NodeJS.ProcessEnv;
+    /** Working directory of the spawned server. `minsync serve` reads `.minsync/config.toml` from it. */
+    readonly cwd?: string;
+    /** How long to wait for the server to publish and answer; the first start may download the model. */
+    readonly readyTimeoutMs?: number;
+    /** Idle seconds before the daemon exits and frees the model (`minsync serve --idle-timeout`). */
+    readonly idleTimeoutSeconds?: number;
+}
+/**
+ * The running `minsync serve` daemon, starting one detached when none answers. The daemon is MinSync's:
+ * it owns the model weights, the cache, and its own idle shutdown. Concurrent starters are safe because
+ * `minsync serve` adopts an already-running server of the same model instead of loading a second copy.
+ */
+export declare function ensureMinSyncDaemon(options: EnsureDaemonOptions): Promise<MinSyncDaemon>;
+export interface StopDaemonOptions extends ProbeOptions {
+    /** How long to wait for the server to remove its discovery files and stop answering. */
+    readonly timeoutMs?: number;
+}
+/**
+ * Stops the running `minsync serve` daemon with SIGTERM, which `minsync serve` handles by removing its
+ * discovery files and exiting. The pid comes from the server's own `GET /health` answer, so only a live
+ * loopback server of the wanted model is ever signalled. Returns the stopped daemon, or undefined when none ran.
+ */
+export declare function stopMinSyncDaemon(options?: StopDaemonOptions): Promise<MinSyncDaemon | undefined>;

package/dist/embedding/embedder.d.ts

@@ -0,0 +1,59 @@
+/**
+ * The contract every semantic consumer in AutoRAG codes against. AutoRAG does not run an embedding model:
+ * vectors come from MinSync (the `minsync serve` daemon, or MinSync's in-process engine) or from a
+ * remote endpoint the operator configured.
+ */
+export interface EmbeddingIdentity {
+    readonly provider: string;
+    readonly model: string;
+    readonly dimension: number;
+}
+/**
+ * What a text is for. Instruction-aware models embed a search query differently from the document it should
+ * match, so a caller says which side it is on. `"document"` is the default.
+ */
+export type EmbedRole = "query" | "document";
+export interface EmbedOptions {
+    readonly role?: EmbedRole;
+}
+export interface Embedder {
+    identity(): Promise<EmbeddingIdentity>;
+    embed(texts: readonly string[], options?: EmbedOptions): Promise<readonly (readonly number[])[]>;
+}
+/** Where a {@link ManagedEmbedder} is sending text right now. `none` means nothing can embed. */
+export type EmbeddingBackend = "daemon" | "in-process" | "remote" | "none";
+/** Whether the embedding backend answers right now. Probed on every call; nothing is cached. */
+export interface EmbedderHealth {
+    readonly backend: EmbeddingBackend;
+    readonly alive: boolean;
+    /** The answering server's address when alive, or why it is not. */
+    readonly detail?: string;
+}
+/** Where a {@link ManagedEmbedder} currently sends text, for external CLIs that need a URL. */
+export interface EmbedderEndpoint {
+    /** Server root; the OpenAI route is under `/v1`, TEI at `/embed`. */
+    readonly baseUrl: string;
+    readonly protocol: "openai" | "tei";
+    readonly model: string;
+    readonly dimension: number | undefined;
+    /** Name of the environment variable that holds the bearer token; remote endpoints only. */
+    readonly apiKeyEnv?: string;
+    /**
+     * Prefixes this endpoint's consumers must apply themselves: the server embeds text as sent. Set only when
+     * the embedder was given prefixes.
+     */
+    readonly queryPrefix?: string;
+    readonly passagePrefix?: string;
+    readonly backend: "daemon" | "remote";
+}
+/**
+ * An {@link Embedder} that reports where it embeds. AutoRAG never starts or stops a server: the operator
+ * runs `minsync serve` or configures a remote endpoint, and `health` / `describeEndpoint` only look.
+ */
+export interface ManagedEmbedder extends Embedder {
+    /** Probes the backend now: the daemon's or the remote's `GET /health`. Never starts anything. */
+    health(): Promise<EmbedderHealth>;
+    /** The HTTP endpoint behind this embedder right now, or undefined while it would embed in-process. */
+    describeEndpoint(): Promise<EmbedderEndpoint | undefined>;
+    close(): Promise<void>;
+}

package/dist/embedding/http-embedder.d.ts

@@ -0,0 +1,28 @@
+import type { Embedder } from "./embedder.js";
+export type EmbeddingProtocol = "openai" | "tei";
+export interface HttpEmbedderOptions {
+    readonly protocol: EmbeddingProtocol;
+    /** Server root, with or without a trailing `/v1` (openai) and trailing slashes. */
+    readonly baseUrl: string;
+    readonly model: string;
+    /** Expected vector length. Learned from the first response when omitted. */
+    readonly dimension?: number;
+    /** Reported as `identity().provider`; stores keyed on identity re-embed when it changes. */
+    readonly provider: string;
+    /** Name of the environment variable holding the bearer token. Read on every call, never stored. */
+    readonly apiKeyEnv?: string;
+    readonly env?: NodeJS.ProcessEnv;
+    /** Inputs per request. */
+    readonly batchSize?: number;
+    /** TEI only: ask the server to truncate inputs over its context instead of answering 413. */
+    readonly truncate?: boolean;
+    readonly timeoutMs?: number;
+    readonly fetchImpl?: typeof fetch;
+}
+/** The daemon rejects bodies over 32 MiB and more than 512 inputs; remote providers cap lower. */
+export declare const DEFAULT_EMBED_BATCH_SIZE = 32;
+/**
+ * Embedder over an HTTP endpoint: a `minsync serve` daemon (either route) or any remote OpenAI-compatible
+ * or TEI server. It owns no model and starts nothing.
+ */
+export declare function createHttpEmbedder(options: HttpEmbedderOptions): Embedder;

package/dist/embedding/in-process.d.ts

@@ -0,0 +1,19 @@
+import type { Embedder } from "./embedder.js";
+/** MinSync's Node-API addon: the same engine, weights and cache as `minsync`'s `native:` embedder. */
+export declare const NATIVE_ADDON_PACKAGE = "@nomadamas/minsync-native";
+export declare const DEFAULT_NATIVE_MODEL_ID = "native:Qwen/Qwen3-Embedding-0.6B";
+export interface InProcessEmbedder extends Embedder {
+    /** Releases the model; later calls reject. */
+    close(): Promise<void>;
+}
+export declare class NativeAddonMissingError extends Error {
+    constructor(cause: unknown);
+}
+/**
+ * Loads MinSync's in-process embedder. AutoRAG ships no model and no inference runtime; the addon is an
+ * optional peer that brings MinSync's engine into this process, and MinSync provisions the weights into its
+ * own cache on first use.
+ */
+export declare function loadNativeEmbedder(options?: {
+    readonly id?: string;
+}): Promise<InProcessEmbedder>;

package/dist/embedding/index.d.ts

@@ -0,0 +1,28 @@
+import type { MinSyncEmbedderConfig } from "../minsync/types.js";
+import type { ManagedEmbedder } from "./embedder.js";
+export { DEFAULT_DAEMON_MODEL, ensureMinSyncDaemon, MinSyncDaemonError, probeMinSyncDaemon, stopMinSyncDaemon, } from "./daemon.js";
+export type { Embedder, EmbedderEndpoint, EmbedderHealth, EmbeddingBackend, EmbeddingIdentity, EmbedOptions, EmbedRole, ManagedEmbedder, } from "./embedder.js";
+export { createHttpEmbedder, type EmbeddingProtocol } from "./http-embedder.js";
+export { loadNativeEmbedder, NATIVE_ADDON_PACKAGE, NativeAddonMissingError } from "./in-process.js";
+export { createManagedEmbedder, type ManagedEmbedderOptions, type RemoteEmbedderSettings } from "./managed.js";
+export { type EmbeddingPrefixes, QWEN3_QUERY_PREFIX, resolveEmbeddingPrefixes } from "./prefixes.js";
+export { remoteEmbedderFromMinSync } from "./settings.js";
+export interface EmbedderFromConfigOptions {
+    /** The `minSync.embedder` block: it selects the embedding backend for MinSync and every other consumer. */
+    readonly embedder?: MinSyncEmbedderConfig;
+    readonly env?: NodeJS.ProcessEnv;
+    /** User home that holds MinSync's `minsync serve` state; defaults to the real home. */
+    readonly home?: string;
+}
+/**
+ * The single embedder AutoRAG shares between its own semantic stores and the datasources: a configured
+ * remote endpoint, else the `minsync serve` daemon the operator runs, else MinSync's in-process engine.
+ * AutoRAG never starts the daemon for it.
+ */
+export declare function createEmbedderFromConfig(options: EmbedderFromConfigOptions): ManagedEmbedder;
+/**
+ * Unload every in-process model this process loaded. A short-lived command calls this on the way out so the
+ * addon's native threads cannot keep the process alive after its answer is written. A `minsync serve` daemon
+ * is not touched: it belongs to the operator.
+ */
+export declare function releaseEmbedders(): Promise<void>;

package/dist/embedding/managed.d.ts

@@ -0,0 +1,44 @@
+import type { ManagedEmbedder } from "./embedder.js";
+import { type EmbeddingProtocol } from "./http-embedder.js";
+import { type InProcessEmbedder } from "./in-process.js";
+import type { EmbeddingPrefixes } from "./prefixes.js";
+/** An operator-configured remote endpoint. When present, AutoRAG never looks for MinSync's daemon. */
+export interface RemoteEmbedderSettings {
+    readonly baseUrl: string;
+    readonly model: string;
+    readonly protocol: EmbeddingProtocol;
+    readonly dimension?: number;
+    readonly apiKeyEnv?: string;
+    readonly batchSize?: number;
+    readonly timeoutMs?: number;
+    /** Reported as the identity provider; defaults to the protocol name. */
+    readonly provider?: string;
+}
+export interface ManagedEmbedderOptions {
+    readonly remote?: RemoteEmbedderSettings;
+    /**
+     * Prepended to every input by role: `query` for `role: "query"`, `passage` otherwise. Applied here, on the
+     * client, for every backend, because neither the daemon nor a remote server is asked to prefix.
+     */
+    readonly prefixes?: EmbeddingPrefixes;
+    /** User home that holds MinSync's server state. */
+    readonly home?: string;
+    readonly env?: NodeJS.ProcessEnv;
+    /** Model of the daemon to use. Defaults to MinSync's default Qwen3 embedder. */
+    readonly model?: string;
+    /** Loads MinSync's in-process engine; only called when no daemon answers. */
+    readonly inProcess?: () => Promise<InProcessEmbedder>;
+    readonly fetchImpl?: typeof fetch;
+}
+/**
+ * The one embedder every AutoRAG consumer shares. AutoRAG owns no embedding model and never starts or stops
+ * a process: the operator runs `minsync serve` (see docs/minsync-setup.md) or points at a remote endpoint.
+ *
+ * - **remote**: a configured endpoint is used as is; nothing local is looked for or loaded.
+ * - **daemon**: a running `minsync serve` is preferred, because it keeps one warm copy of the model for every
+ *   process. It is looked up again on every call, so one started or stopped while AutoRAG runs is noticed.
+ * - **in-process**: MinSync's own engine, used when no daemon answers. Daemon and in-process vectors are
+ *   identical for the same model and device, so both report one identity and stores never re-embed
+ *   because the daemon came or went.
+ */
+export declare function createManagedEmbedder(options: ManagedEmbedderOptions): ManagedEmbedder;

package/dist/embedding/prefixes.d.ts

@@ -0,0 +1,18 @@
+import type { MinSyncEmbedderConfig } from "../minsync/types.js";
+/**
+ * Qwen3-Embedding is instruction-aware: the query side is `Instruct: {task}\nQuery:{query}` and documents are
+ * embedded raw (model card `get_detailed_instruct`; there is no space after `Query:`). The task stays in
+ * English even for non-English queries, as the card recommends.
+ */
+export declare const QWEN3_QUERY_PREFIX = "Instruct: Given a web search query, retrieve relevant passages that answer the query\nQuery:";
+/** Text prepended to an embedding input, by what the input is for. */
+export interface EmbeddingPrefixes {
+    readonly query: string;
+    readonly passage: string;
+}
+/**
+ * The query and passage prefixes for the embedder `minSync.embedder` describes. An operator value, including
+ * `""`, always wins. Without one, MinSync's local Qwen3 gets the model's own query instruction; every other
+ * model gets none, because its prefix scheme is unknown here.
+ */
+export declare function resolveEmbeddingPrefixes(embedder: MinSyncEmbedderConfig | undefined): EmbeddingPrefixes;

package/dist/embedding/settings.d.ts

@@ -0,0 +1,9 @@
+import type { MinSyncEmbedderConfig } from "../minsync/types.js";
+import type { RemoteEmbedderSettings } from "./managed.js";
+/**
+ * The remote endpoint that `minSync.embedder` describes, if any. The same block configures MinSync itself
+ * and every AutoRAG-owned consumer (memory, chat sidecars, gist, discrawl), so one remote setting reaches
+ * all of them. `tei:` ids and a `baseUrl` mean a remote server; `openai:` ids default to api.openai.com;
+ * `native:` ids, a missing id, and a missing endpoint mean MinSync's local Qwen3.
+ */
+export declare function remoteEmbedderFromMinSync(embedder: MinSyncEmbedderConfig | undefined): RemoteEmbedderSettings | undefined;