@autorag/librarian 2.10.4 → 2.10.6

package/dist/datasource/embedding-env.d.ts

@@ -0,0 +1,29 @@
+import type { EmbedderEndpoint, ManagedEmbedder } from "../embedding/embedder.js";
+/**
+ * Pointing an external CLI that embeds for itself (mailcrawl, lazykatok) at the same backend as the rest of
+ * AutoRAG. The CLI keeps ownership of its archive and vector store; AutoRAG only tells it where the vectors
+ * come from, through the environment variables the CLI documents. A remote key travels as the value of the
+ * variable the operator's `minSync.embedder.apiKeyEnv` names, to that one child only.
+ */
+/** An endpoint whose vector length is known; the CLIs require it up front. */
+export interface ResolvedEmbeddingEndpoint extends EmbedderEndpoint {
+    readonly dimension: number;
+}
+export type EmbeddingEndpointSource = () => Promise<ResolvedEmbeddingEndpoint | undefined>;
+/**
+ * The shared embedder as an endpoint source. Probes only: it never starts a daemon. `undefined` means the
+ * embedder would run in-process, which an external CLI cannot reach.
+ */
+export declare function embeddingEndpointSource(embedder: ManagedEmbedder): EmbeddingEndpointSource;
+/**
+ * mailcrawl's `openai` and `tei` providers (0.2.2+). Identity is provider + model + dimension, so moving a
+ * server keeps its vectors, while switching backend rebuilds the index on the next `mailcrawl index`.
+ * mailcrawl accepts a non-loopback endpoint only over https with an explicit opt-in, which is set here
+ * because the operator configured that remote themselves.
+ */
+export declare function mailcrawlEmbeddingEnv(endpoint: ResolvedEmbeddingEndpoint, parentEnv?: NodeJS.ProcessEnv): Record<string, string>;
+/**
+ * lazykatok's OpenAI-compatible embedder (0.3.3+). It speaks `POST /v1/embeddings` only, so a TEI endpoint
+ * cannot be offered and lazykatok keeps its own embedder, as discrawl does.
+ */
+export declare function lazykatokEmbeddingEnv(endpoint: ResolvedEmbeddingEndpoint, parentEnv?: NodeJS.ProcessEnv): Record<string, string> | undefined;

package/dist/datasource/sidecar/config.d.ts

@@ -12,6 +12,7 @@
  * The sidecar's own database always lives under the AutoRAG workspace, one file
  * per datasource instance, never next to (or inside) the crawler's archive.
  */
+import type { Embedder } from "../../embedding/embedder.js";
 import type { CrawlerDescriptor } from "./descriptors.js";
 import type { CrawlerSidecarOptions } from "./index.js";
 export interface ResolveSidecarInput {
@@ -22,5 +23,7 @@ export interface ResolveSidecarInput {
     readonly instanceId: string;
     /** Where the crawler keeps its archive when the user did not say. */
     readonly defaultCrawlerDb: string;
+    /** The embedder shared with the rest of AutoRAG. Without one the sidecar is lexical-only. */
+    readonly embedder?: Embedder;
 }
 export declare function resolveSidecarOptions(input: ResolveSidecarInput): CrawlerSidecarOptions | undefined;

package/dist/datasource/sidecar/index.d.ts

@@ -11,7 +11,7 @@
  * Everything crawler-specific lives in a {@link CrawlerDescriptor}; this file
  * is shared by every crawler.
  */
-import type { Embedder } from "../../embedding-runtime/gateway-embedder.js";
+import type { Embedder } from "../../embedding/embedder.js";
 import type { CrawlerDescriptor } from "./descriptors.js";
 export interface SidecarHit {
     readonly key: string;

package/dist/datasource/skills/discrawl/client.d.ts

@@ -13,6 +13,7 @@ export declare class DiscrawlClient {
     private readonly options;
     constructor(options?: DiscrawlOptions);
     configureEmbeddings(runtime: DiscrawlEmbeddingRuntime): Promise<DiscrawlEmbeddingConfigResult>;
+    private resolveRuntime;
     prepareEmbeddings(): Promise<boolean>;
     metadata(signal?: AbortSignal): Promise<DiscrawlMetadataResult>;
     doctor(signal?: AbortSignal): Promise<DiscrawlDoctorResult>;

package/dist/datasource/skills/discrawl/embedding.d.ts

@@ -0,0 +1,17 @@
+import type { EmbedderEndpoint } from "../../../embedding/embedder.js";
+import type { DiscrawlEmbeddingRuntime } from "./types.js";
+/**
+ * discrawl keeps `openai_compatible` embeddings off ("requires API key env ...") unless the variable its
+ * config names is non-empty, while `minsync serve` has no authentication and ignores the value. For the
+ * local daemon AutoRAG therefore names a variable of its own and supplies this fixed, non-secret placeholder
+ * to the discrawl child only. It is never a credential and never read from the operator's environment.
+ */
+export declare const LOCAL_EMBEDDING_KEY_ENV = "AUTORAG_LOCAL_EMBEDDING_KEY";
+export declare const LOCAL_EMBEDDING_KEY_PLACEHOLDER = "local";
+/**
+ * What discrawl's own `[search.embeddings]` section should say so that it embeds through the same backend
+ * as the rest of AutoRAG. discrawl speaks OpenAI `POST {base_url}/embeddings` only (its provider name is
+ * `openai_compatible`, with an underscore), so a TEI endpoint cannot be offered and discrawl keeps its own
+ * configuration. A remote key travels as the name of an environment variable, never as a value.
+ */
+export declare function discrawlEmbeddingRuntimeFor(endpoint: EmbedderEndpoint | undefined): DiscrawlEmbeddingRuntime | undefined;

package/dist/datasource/skills/discrawl/types.d.ts

@@ -43,7 +43,12 @@ export interface DiscrawlEmbeddingRuntime {
     readonly provider: string;
     readonly model: string;
     readonly baseUrl: string;
-    readonly dimensions: number;
+    /** Omitted when the endpoint's dimension is not known; discrawl infers it from the first response. */
+    readonly dimensions?: number;
+    /** Name of the environment variable that holds the bearer token (remote endpoints). Never the token. */
+    readonly apiKeyEnv?: string;
+    /** A non-secret placeholder for a keyless local daemon, passed to the child only. Never set for a remote endpoint. */
+    readonly apiKeyValue?: string;
     readonly identity?: string;
 }
 export interface DiscrawlEmbeddingConfigResult {
@@ -78,8 +83,11 @@ export interface DiscrawlOptions {
     readonly guildId?: string;
     /** Embedding provider understood by the native discrawl configuration. */
     readonly embeddingProvider?: string;
-    /** AutoRAG-owned runtime to write into a managed workspace config. */
-    readonly embeddingRuntime?: DiscrawlEmbeddingRuntime;
+    /**
+     * Where discrawl should embed, written into a managed workspace config. A function is evaluated on each
+     * `prepareEmbeddings`, because the endpoint of a `minsync serve` daemon exists only while it runs.
+     */
+    readonly embeddingRuntime?: DiscrawlEmbeddingRuntime | (() => Promise<DiscrawlEmbeddingRuntime | undefined>);
     /**
      * Embedding model understood by the native discrawl configuration.
      * English-only models are accepted but reported through a diagnostic.

package/dist/datasource/skills/factory.d.ts

@@ -7,6 +7,8 @@
  * configuration path. Unknown skill names and disabled entries are skipped
  * and reported so setup surfaces actionable (but path-opaque) feedback.
  */
+import type { Embedder } from "../../embedding/embedder.js";
+import type { EmbeddingEndpointSource } from "../embedding-env.js";
 import type { DatasourceSkill } from "../types.js";
 import { type DiscrawlEmbeddingRuntime } from "./discrawl/index.js";
 /** One configured datasource entry (the trusted `datasources.<name>` value). */
@@ -34,6 +36,17 @@ export interface BuildDatasourceSkillsResult {
     /** Names that were configured but not recognized. */
     readonly unknown: readonly string[];
 }
+/**
+ * What the shared embedding backend gives a datasource. AutoRAG-owned semantic stores (chat sidecars, the
+ * gist vector index) call the `embedder`; an external CLI that embeds for itself (discrawl) is pointed at the
+ * same backend through `discrawl`.
+ */
+export interface DatasourceEmbeddingOptions {
+    readonly embedder?: Embedder;
+    readonly discrawl?: DiscrawlEmbeddingRuntime | (() => Promise<DiscrawlEmbeddingRuntime | undefined>);
+    /** For CLIs that embed for themselves through env (mailcrawl, lazykatok): where the shared backend is. */
+    readonly cliEndpoint?: EmbeddingEndpointSource;
+}
 /** Skill names this factory can build. */
 export declare const BUILTIN_DATASOURCE_SKILL_NAMES: readonly string[];
 /**
@@ -42,4 +55,4 @@ export declare const BUILTIN_DATASOURCE_SKILL_NAMES: readonly string[];
  * collected in `unknown` (never thrown) so callers can surface setup
  * feedback without failing agent construction.
  */
-export declare function buildDatasourceSkills(config: DatasourcesConfig | undefined, workspaceRoot?: string, embeddingRuntime?: DiscrawlEmbeddingRuntime): BuildDatasourceSkillsResult;
+export declare function buildDatasourceSkills(config: DatasourcesConfig | undefined, workspaceRoot?: string, embedding?: DatasourceEmbeddingOptions): BuildDatasourceSkillsResult;

package/dist/datasource/skills/github-gist/semantic.d.ts

@@ -4,12 +4,12 @@
  * A small persisted vector sidecar (`vectors.json`) mirrors the chunk store:
  * entries are keyed by chunk id with a content hash so unchanged chunks are
  * never re-embedded, removed chunks are pruned, and an embedding-identity
- * change (provider/model/dimension) forces a full re-embed. The default
- * embedder talks to the loopback autorag-gateway (`ensureRuntime` with
- * `cachedOnly`, then `POST /v1/embeddings`); tests inject a stub. Every
- * failure degrades — indexing stays lexical-only and retrieval returns [].
+ * change (provider/model/dimension) forces a full re-embed. The embedder is
+ * the one AutoRAG shares with every consumer (MinSync's daemon or in-process
+ * engine, or the configured remote endpoint). Every failure degrades —
+ * indexing stays lexical-only and retrieval returns [].
  */
-import type { Embedder } from "../../../embedding-runtime/gateway-embedder.js";
+import type { Embedder } from "../../../embedding/embedder.js";
 import type { RetrievalMethod, RetrievalMethodDescriptor, RetrievalOptions, RetrievalResult } from "../../../retrieval/types.js";
 import type { DatasourceChunkStore, StoredChunk } from "../../chunk-store.js";
 export interface GistSemanticSyncOk {

package/dist/datasource/skills/github-gist/skill.d.ts

@@ -7,7 +7,7 @@
  * through the loopback embedding gateway. Embedding failures degrade to a
  * `semantic-unavailable` warning — indexing and lexical retrieval continue.
  */
-import { type Embedder, type GatewayEmbedderOptions } from "../../../embedding-runtime/gateway-embedder.js";
+import type { Embedder } from "../../../embedding/embedder.js";
 import type { RetrievalMethod } from "../../../retrieval/types.js";
 import { ConnectorDatasourceSkill, type ConnectorSkillDefinition, type ConnectorSkillOptions } from "../../connector-skill.js";
 import type { DatasourceIndexOptions, DatasourceIndexResult } from "../../types.js";
@@ -17,9 +17,8 @@ export declare function gistDatasourceDir(workspaceRoot: string, skillName: stri
 export interface GitHubGistSemanticOptions {
     /** Set false to run lexical-only. Default true. */
     readonly enabled?: boolean;
-    /** Injected embedder (tests); defaults to the loopback gateway embedder. */
+    /** The embedder shared with the rest of AutoRAG. Without one the gist index is lexical-only. */
     readonly embedder?: Embedder;
-    readonly embedderOptions?: GatewayEmbedderOptions;
     /** Vector sidecar path override; defaults under `.autorag/datasources/…`. */
     readonly statePath?: string;
 }

package/dist/datasource/skills/lazykatok/types.d.ts

@@ -1,4 +1,5 @@
 import type { RetrievalOptions } from "../../../retrieval/types.js";
+import type { EmbeddingEndpointSource } from "../../embedding-env.js";
 /**
  * Search modes accepted by the external `lazykatok search` subcommand.
  *
@@ -43,6 +44,13 @@ export interface LazykatokOptions {
     readonly source?: string;
     /** Environment overrides merged on top of `process.env` for the child. */
     readonly env?: Readonly<Record<string, string | undefined>>;
+    /**
+     * Where lazykatok gets its vectors. When set, `index` and the semantic and hybrid searches run lazykatok's
+     * OpenAI-compatible embedder against the endpoint it returns (a `minsync serve` daemon or the operator's
+     * remote), and lazykatok's own fastembed model is never used; with no endpoint, or a TEI one, those commands
+     * fail instead. Without it lazykatok keeps whatever embedder its own environment selects.
+     */
+    readonly embeddingEndpoint?: EmbeddingEndpointSource;
 }
 export declare const DEFAULT_LAZYKATOK_BINARY = "lazykatok";
 export declare const DEFAULT_LAZYKATOK_TIMEOUT_MS = 60000;
@@ -65,7 +73,7 @@ export declare const DEFAULT_LAZYKATOK_OPTIONS: {
  * every method returns a discriminated union with `ok: false` and one of these
  * reasons.
  */
-export type LazykatokFailureReason = "binary-missing" | "nonzero-exit" | "spawn-error" | "timeout" | "aborted" | "stdout-too-large" | "stderr-too-large" | "invalid-json" | "invalid-shape";
+export type LazykatokFailureReason = "binary-missing" | "nonzero-exit" | "spawn-error" | "timeout" | "aborted" | "stdout-too-large" | "stderr-too-large" | "invalid-json" | "invalid-shape" | "embedding-unavailable";
 /** Common failure payload shared by every method result union. */
 export interface LazykatokFailure {
     readonly ok: false;

package/dist/datasource/skills/mailcrawl/types.d.ts

@@ -1,3 +1,4 @@
+import type { EmbeddingEndpointSource } from "../../embedding-env.js";
 export type MailcrawlSearchMode = "keyword" | "bm25" | "semantic" | "hybrid";
 export interface MailcrawlSearchOptions {
     readonly topK?: number;
@@ -22,8 +23,15 @@ export interface MailcrawlOptions {
     readonly indexTimeoutMs?: number;
     readonly maxBufferBytes?: number;
     readonly env?: Readonly<Record<string, string | undefined>>;
+    /**
+     * Where mailcrawl gets its vectors. When set, `index` and the semantic and hybrid searches run mailcrawl's
+     * `openai`/`tei` provider against the endpoint it returns (a `minsync serve` daemon or the operator's remote),
+     * and mailcrawl's own native model is never used; with no endpoint those commands fail instead. Without it
+     * mailcrawl keeps whatever embedder its own environment selects.
+     */
+    readonly embeddingEndpoint?: EmbeddingEndpointSource;
 }
-export type MailcrawlFailureReason = "binary-missing" | "not-configured" | "nonzero-exit" | "spawn-error" | "timeout" | "aborted" | "stdout-too-large" | "stderr-too-large" | "invalid-output" | "remote-embedding-rejected";
+export type MailcrawlFailureReason = "binary-missing" | "not-configured" | "nonzero-exit" | "spawn-error" | "timeout" | "aborted" | "stdout-too-large" | "stderr-too-large" | "invalid-output" | "remote-embedding-rejected" | "embedding-unavailable";
 export interface MailcrawlFailure {
     readonly ok: false;
     readonly reason: MailcrawlFailureReason;

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;