@autorag/librarian 2.10.1 → 2.10.2

package/dist/cloud/config.d.ts

@@ -1,10 +1,21 @@
-/** Provider identity and endpoint configuration for the hosted AutoRAG (Dazzi) plan. */
-export declare const PROVIDER_ID = "autorag";
-export declare const PROVIDER_NAME = "AutoRAG";
+/** Provider identity and endpoint configuration for the hosted Dazzi Models plan. */
+export declare const PROVIDER_ID = "dazzi";
+export declare const PROVIDER_NAME = "Dazzi Models";
+/**
+ * Chat model used when nothing is configured and the user is signed in. Used only
+ * if the live or persisted catalog lists it; otherwise the first catalog model.
+ */
+export declare const DEFAULT_DAZZI_CHAT_MODEL_ID = "anthropic/claude-haiku-5.5";
+/**
+ * Question-decomposition model used when nothing is configured and the user is
+ * signed in. `z-ai/glm-5.3-flash` is not usable here: it requires reasoning, and
+ * the decomposition call runs with reasoning off. Same catalog caveat as
+ * {@link DEFAULT_DAZZI_CHAT_MODEL_ID}: the model must be in the signed-in catalog.
+ */
+export declare const DEFAULT_DAZZI_QUERY_DECOMPOSITION_MODEL_ID = "openai/gpt-6-luna";
 /** Server root, e.g. `https://api.dazziapp.com`. The API lives under `<root>/v1`. */
 export declare const DEFAULT_BASE_URL = "https://api.dazziapp.com";
 export declare const AUTORAG_BASE_URL_ENV = "AUTORAG_BASE_URL";
-export declare const AUTORAG_API_KEY_ENV = "AUTORAG_API_KEY";
 /** Server paths appended to the normalized server root. */
 export declare const API_PATH = "/v1";
 export declare const MODELS_PATH = "/v1/models";
@@ -20,7 +31,7 @@ export declare const TOKEN_PATH = "/api/desktop/token";
  * cap leaves headroom for the tool declarations and request framing the
  * transcript size does not count; the resize cap keeps one image well below it.
  */
-export declare const AUTORAG_INPUT_LIMITS: {
+export declare const DAZZI_INPUT_LIMITS: {
     readonly maxRequestBytes: 3500000;
     readonly images: {
         readonly resize: {
@@ -30,11 +41,6 @@ export declare const AUTORAG_INPUT_LIMITS: {
 };
 /** OAuth client identifier for the AutoRAG agent (Pi-compatible hosts use `pi`). */
 export declare const OAUTH_CLIENT_ID = "agent";
-/**
- * Value used for `ProviderConfig.apiKey`. Pi resolves `$NAME` from the
- * environment, so `AUTORAG_API_KEY` enables a headless, login-free setup.
- */
-export declare const API_KEY_CONFIG_VALUE = "$AUTORAG_API_KEY";
 /** Trim whitespace and trailing slashes so path concatenation is unambiguous. */
 export declare function normalizeBaseUrl(value: string): string;
 /** Server root from `AUTORAG_BASE_URL`, falling back to {@link DEFAULT_BASE_URL}. */

package/dist/cloud/credential.d.ts

@@ -0,0 +1,17 @@
+/** Message for every Dazzi-backed feature used without a stored `/login` credential. */
+export declare const DAZZI_LOGIN_REQUIRED_MESSAGE = "Dazzi Models needs a sign-in: run `autorag tui`, then `/login` and choose Dazzi Models.";
+/**
+ * The bearer token `/login` stored for the Dazzi Models plan, or `undefined`
+ * when the user has not signed in.
+ *
+ * Login is the only credential: Dazzi's `/v1/*` endpoints take the key the
+ * sign-in flow issues, so Jev and rerank read the same `auth.json` entry the
+ * model provider uses. `agentDir` defaults to Pi's agent home.
+ */
+export declare function readDazziLoginToken(agentDir?: string): string | undefined;
+/**
+ * Whether a `/login` credential for Dazzi Models is stored. Defaults (Jev,
+ * rerank, question decomposition, the chat model) follow this: signed in means
+ * the hosted plan, signed out keeps the OpenRouter defaults.
+ */
+export declare function isDazziSignedIn(agentDir?: string): boolean;

package/dist/cloud/errors.d.ts

@@ -1,28 +1,28 @@
 /**
- * Error types for the hosted AutoRAG (Dazzi) provider.
+ * Error types for the hosted Dazzi Models provider.
  *
  * Messages never contain credentials, authorization headers, or provider
  * payloads; they are safe to surface in the CLI UI and in test assertions.
  */
-/** Base class for every error raised by the AutoRAG provider. */
-export declare class AutoragError extends Error {
+/** Base class for every error raised by the Dazzi Models provider. */
+export declare class DazziError extends Error {
     constructor(message: string, options?: {
         cause?: unknown;
     });
 }
 /** Raised for OAuth/PKCE/callback failures. */
-export declare class AutoragOAuthError extends AutoragError {
+export declare class DazziOAuthError extends DazziError {
     constructor(message: string, options?: {
         cause?: unknown;
     });
 }
 /**
- * Raised when an HTTP call to AutoRAG fails.
+ * Raised when an HTTP call to Dazzi Models fails.
  *
  * `status` is the HTTP status code, `code`/`type` come from the OpenAI-shaped
  * error body when the server supplies them.
  */
-export declare class AutoragHttpError extends AutoragError {
+export declare class DazziHttpError extends DazziError {
     readonly status: number;
     readonly code?: string;
     readonly type?: string;

package/dist/cloud/index.d.ts

@@ -3,10 +3,11 @@ export { buildAuthorizeUrl } from "./authorize.js";
 export type { CallbackResult } from "./callback.js";
 export { parseCallbackInput, parseCallbackQuery, requireAuthorizationCode } from "./callback.js";
 export { CALLBACK_PATH, type CallbackServer, type CallbackServerOptions, DEFAULT_LOGIN_TIMEOUT_MS, startCallbackServer, } from "./callback-server.js";
-export { API_KEY_CONFIG_VALUE, API_PATH, AUTHORIZE_PATH, AUTORAG_API_KEY_ENV, AUTORAG_BASE_URL_ENV, DEFAULT_BASE_URL, MODELS_PATH, normalizeBaseUrl, OAUTH_CLIENT_ID, PROVIDER_ID, PROVIDER_NAME, resolveBaseUrl, TOKEN_PATH, } from "./config.js";
-export { AutoragError, AutoragHttpError, AutoragOAuthError, type ErrorPayload, extractErrorPayload, } from "./errors.js";
+export { API_PATH, AUTHORIZE_PATH, AUTORAG_BASE_URL_ENV, DEFAULT_BASE_URL, MODELS_PATH, normalizeBaseUrl, OAUTH_CLIENT_ID, PROVIDER_ID, PROVIDER_NAME, resolveBaseUrl, TOKEN_PATH, } from "./config.js";
+export { DAZZI_LOGIN_REQUIRED_MESSAGE, readDazziLoginToken } from "./credential.js";
+export { DazziError, DazziHttpError, DazziOAuthError, type ErrorPayload, extractErrorPayload, } from "./errors.js";
 export { buildStoreEntry, DEFAULT_CONTEXT_WINDOW, DEFAULT_MAX_TOKENS, type FetchModelsOptions, fetchModels, mapModelsError, mapServerModel, mapServerModels, modelsFromStore, resolveCredentialKey, } from "./models.js";
-export { type LoginOptions, loginAutorag, refreshAutoragCredentials } from "./oauth-login.js";
+export { type LoginOptions, loginDazzi, refreshDazziCredentials } from "./oauth-login.js";
 export { base64UrlEncode, createCodeChallenge, createCodeVerifier, createPkcePair, createState, type PkcePair, } from "./pkce.js";
-export { type AutoragEnv, createAutoRAGProviderConfig, refreshAutoragModels, registerAutoRAGProvider, } from "./provider.js";
+export { createDazziProviderConfig, type DazziEnv, refreshDazziModels, registerDazziProvider, } from "./provider.js";
 export { type ExchangeCodeOptions, exchangeCodeForToken, mapTokenExchangeError, type TokenResponse } from "./token.js";

package/dist/cloud/jev-backend.d.ts

@@ -1,8 +1,8 @@
 /**
- * Jev backend for the hosted AutoRAG (Dazzi) plan.
+ * Jev backend for the hosted Dazzi Models plan.
  *
  * The server answers Jev's native dialect at `POST <root>/v1/jev` behind the
- * account bearer key (`AUTORAG_API_KEY`), returning the same `answers` map the
+ * Dazzi login token (stored by `/login`), returning the same `answers` map the
  * TypeSafe and OpenRouter backends do. `jev-use`'s package index does not
  * export its native-dialect helpers, so the small mapping and the retrying JSON
  * transport are reimplemented here against that documented dialect (covered by
@@ -15,17 +15,19 @@
 import { type BackendRequest, type BackendResponse, type JevBackend, type Question, type RawAnswer, type State } from "jev-use";
 /** API path appended to the normalized server root. */
 export declare const JEV_PATH = "/v1/jev";
-/** Live Jev model id on the hosted AutoRAG plan. */
-export declare const AUTORAG_DEFAULT_JEV_MODEL = "jev-1.13";
-/** Options for {@link AutoragJevBackend}. */
-export interface AutoragJevBackendOptions {
-    /** Environment holding the bearer key and `AUTORAG_BASE_URL`. Default `process.env`. */
+/** Live Jev model id on the hosted Dazzi Models plan. */
+export declare const DAZZI_DEFAULT_JEV_MODEL = "jev-1.13";
+/** Options for {@link DazziJevBackend}. */
+export interface DazziJevBackendOptions {
+    /** Environment holding `AUTORAG_BASE_URL`. Default `process.env`. */
     readonly env?: Record<string, string | undefined>;
-    /** Explicit bearer key; when omitted, read from `AUTORAG_API_KEY`. */
+    /** Pi agent home whose `auth.json` holds the `/login` credential. Default: Pi's agent dir. */
+    readonly agentDir?: string;
+    /** Explicit bearer token (test seam); when omitted, the stored login token is used. */
     readonly apiKey?: string;
     /** Override the server root (test seam); defaults to `resolveBaseUrl(env)`. */
     readonly baseUrl?: string;
-    /** Model used when a call names none. @default AUTORAG_DEFAULT_JEV_MODEL */
+    /** Model used when a call names none. @default DAZZI_DEFAULT_JEV_MODEL */
     readonly defaultModel?: string;
     /** Abort one attempt after this long. @default 10_000 */
     readonly timeoutMs?: number;
@@ -56,21 +58,21 @@ interface NativeBody {
     questions: Record<string, NativeWireQuestion>;
 }
 /**
- * Jev backend served by the hosted AutoRAG (Dazzi) plan.
+ * Jev backend served by the hosted Dazzi Models plan.
  *
  * The constructor throws a named error when no account key is configured — a
  * missing credential must be loud, never a silent fake judgment — and the retry
  * policy mirrors `jev-use`'s own remote backends (408/429/5xx, `Retry-After`).
  */
-export declare class AutoragJevBackend implements JevBackend {
-    readonly name = "autorag";
+export declare class DazziJevBackend implements JevBackend {
+    readonly name = "dazzi";
     private readonly apiKey;
     private readonly baseUrl;
     private readonly defaultModel;
     private readonly timeoutMs;
     private readonly maxRetries;
     private readonly fetchImpl;
-    constructor(options?: AutoragJevBackendOptions);
+    constructor(options?: DazziJevBackendOptions);
     judge(request: BackendRequest): Promise<BackendResponse>;
     /** POST JSON with a per-attempt timeout and jev-use's retry policy. */
     private postJson;

package/dist/cloud/models.d.ts

@@ -1,13 +1,13 @@
 import type { Credential, ModelsStoreEntry } from "@earendil-works/pi-ai";
 import type { ProviderModelConfig } from "@earendil-works/pi-coding-agent";
-import { AutoragHttpError } from "./errors.js";
+import { DazziHttpError } from "./errors.js";
 /** Used when the server omits `context_window` / `max_output_tokens`. */
 export declare const DEFAULT_CONTEXT_WINDOW = 128000;
 export declare const DEFAULT_MAX_TOKENS = 16384;
 export interface FetchModelsOptions {
     /** Server root, e.g. `https://api.dazziapp.com`. */
     baseUrl: string;
-    /** Bearer token resolved from OAuth credentials or `AUTORAG_API_KEY`. */
+    /** Bearer token from the stored `/login` credential. */
     apiKey: string;
     signal?: AbortSignal;
     fetchImpl?: typeof fetch;
@@ -21,10 +21,10 @@ export declare function resolveCredentialKey(credential: Credential | undefined)
  */
 export declare function fetchModels(options: FetchModelsOptions): Promise<ProviderModelConfig[]>;
 /** Map a failed `/v1/models` response; 401 means the token is invalid or revoked. */
-export declare function mapModelsError(status: number, body: unknown): AutoragHttpError;
+export declare function mapModelsError(status: number, body: unknown): DazziHttpError;
 /** Map an OpenAI-shaped `{ object: "list", data: [...] }` catalog body. */
 export declare function mapServerModels(payload: unknown): ProviderModelConfig[];
-/** Map a single AutoRAG model record; returns `undefined` when it has no usable id. */
+/** Map a single Dazzi Models record; returns `undefined` when it has no usable id. */
 export declare function mapServerModel(entry: Record<string, unknown>): ProviderModelConfig | undefined;
 /** Snapshot the live catalog for offline startup. */
 export declare function buildStoreEntry(models: readonly ProviderModelConfig[], providerId: string, baseUrl: string): ModelsStoreEntry;

package/dist/cloud/oauth-login.d.ts

@@ -7,10 +7,10 @@ export interface LoginOptions {
     fetchImpl?: typeof fetch;
 }
 /**
- * AutoRAG tokens are long-lived revocable API keys: there is no refresh token
+ * Dazzi Models tokens are long-lived revocable API keys: there is no refresh token
  * and no expiry, so a refresh returns the stored credentials unchanged.
  */
-export declare function refreshAutoragCredentials(credentials: OAuthCredentials): OAuthCredentials;
+export declare function refreshDazziCredentials(credentials: OAuthCredentials): OAuthCredentials;
 /**
  * OAuth2 authorization-code + PKCE (S256) login for native apps.
  *
@@ -19,4 +19,4 @@ export declare function refreshAutoragCredentials(credentials: OAuthCredentials)
  * the final redirect URL (or the bare code) into the prompt instead; both paths
  * are raced and the first result wins.
  */
-export declare function loginAutorag(callbacks: OAuthLoginCallbacks, options: LoginOptions): Promise<OAuthCredentials>;
+export declare function loginDazzi(callbacks: OAuthLoginCallbacks, options: LoginOptions): Promise<OAuthCredentials>;

package/dist/cloud/provider.d.ts

@@ -1,17 +1,16 @@
 /**
- * The hosted AutoRAG (Dazzi) plan as a first-class model provider named
- * `autorag`.
+ * The hosted Dazzi Models plan as a first-class model provider named `dazzi`.
  *
  * The server exposes an OpenAI Responses API surface under `<root>/v1`. Login
- * is OAuth2 authorization-code + PKCE over a loopback redirect (or the headless
- * `AUTORAG_API_KEY`), and the model catalog is discovered live from
+ * is OAuth2 authorization-code + PKCE over a loopback redirect and is the only
+ * way to authenticate; the model catalog is discovered live from
  * `GET <root>/v1/models` — no model id is ever hardcoded here. Streaming is
  * delegated to Pi's built-in `openai-responses` API implementation.
  */
 import type { RefreshModelsContext } from "@earendil-works/pi-ai";
 import type { ModelRuntime, ProviderConfig, ProviderModelConfig } from "@earendil-works/pi-coding-agent";
 /** Injection seam for tests and hosts that resolve configuration themselves. */
-export type AutoragEnv = Record<string, string | undefined>;
+export type DazziEnv = Record<string, string | undefined>;
 interface Endpoints {
     /** Server root, used for OAuth endpoints. */
     baseUrl: string;
@@ -25,16 +24,22 @@ interface Endpoints {
  * credential (or without network access) the last persisted catalog, if any,
  * is restored; a failed fetch keeps the previous list instead of blanking it.
  */
-export declare function refreshAutoragModels(context: RefreshModelsContext, endpoints: Endpoints): Promise<ProviderModelConfig[]>;
-/** Build the `ProviderConfig` handed to `ModelRuntime.registerProvider("autorag", ...)`. */
-export declare function createAutoRAGProviderConfig(env?: AutoragEnv): ProviderConfig;
+export declare function refreshDazziModels(context: RefreshModelsContext, endpoints: Endpoints): Promise<ProviderModelConfig[]>;
 /**
- * The single registration point: register `autorag` on a Pi `ModelRuntime`.
+ * Build the `ProviderConfig` handed to `ModelRuntime.registerProvider("dazzi", ...)`.
  *
- * Runs even when the user is not signed in, so `/login` lists AutoRAG. The
+ * No `apiKey` is declared: the provider is OAuth-only, so a signed-out refresh
+ * restores the persisted snapshot without an error and `/login` still lists
+ * Dazzi Models.
+ */
+export declare function createDazziProviderConfig(env?: DazziEnv): ProviderConfig;
+/**
+ * The single registration point: register `dazzi` on a Pi `ModelRuntime`.
+ *
+ * Runs even when the user is not signed in, so `/login` lists Dazzi Models. The
  * awaited cache-only refresh loads the persisted catalog snapshot (offline and
  * with `allowModelNetwork:false`); it makes no network call, so a signed-out
  * provider contributes no models and nothing here reaches the network.
  */
-export declare function registerAutoRAGProvider(runtime: ModelRuntime, env?: AutoragEnv): Promise<void>;
+export declare function registerDazziProvider(runtime: ModelRuntime, env?: DazziEnv): Promise<void>;
 export {};

package/dist/cloud/token.d.ts

@@ -1,4 +1,4 @@
-import { AutoragHttpError } from "./errors.js";
+import { DazziHttpError } from "./errors.js";
 export interface TokenResponse {
     accessToken: string;
     email?: string;
@@ -13,7 +13,7 @@ export interface ExchangeCodeOptions {
     fetchImpl?: typeof fetch;
 }
 /** Map a failed token-exchange response to an error carrying the HTTP status and server code. */
-export declare function mapTokenExchangeError(status: number, body: unknown): AutoragHttpError;
+export declare function mapTokenExchangeError(status: number, body: unknown): DazziHttpError;
 /**
  * Trade a PKCE authorization code for a long-lived API key.
  *

package/dist/core.d.ts

@@ -4,6 +4,7 @@ import { type SearchDocumentsResponse } from "./agent/search-documents.js";
 import { type CliConfig, type ResolveConfigInput } from "./cli/config.js";
 import type { EverythingSearchRequest, EverythingSearchResult } from "./everything/index.js";
 import type { FSearchSearchRequest, FSearchSearchResult } from "./fsearch/index.js";
+import type { JikjiPrepareOptions } from "./jikji/index.js";
 import type { MemorySchema } from "./memory/memory.js";
 import type { MinSyncSyncResult } from "./minsync/types.js";
 import type { ParsedMirrorSyncResult } from "./mirror/sync.js";
@@ -37,7 +38,7 @@ export declare class AutoRAGLite {
     /** Run the configured MinSync indexer without constructing a model. */
     syncMinSync(): Promise<MinSyncSyncResult | undefined>;
     /** Run the configured Jikji preparer without constructing a model. */
-    prepareJikji(): Promise<readonly AutoRAGJikjiPrepareResult[] | undefined>;
+    prepareJikji(options?: JikjiPrepareOptions): Promise<readonly AutoRAGJikjiPrepareResult[] | undefined>;
     /** Start an opt-in incremental filesystem refresh watcher. */
     startWatchRefresh(options?: AutoRAGWatchRefreshOptions): AutoRAGWatchRefreshHandle;
     /** Return the deterministic retrieval engine used by this configured runtime. */