@autorag/librarian 2.5.1 → 2.5.3

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

@@ -0,0 +1,134 @@
+import type { RetrievalOptions } from "../../../retrieval/types.js";
+/**
+ * Search modes accepted by the external `lazykatok search` subcommand.
+ *
+ * - `semantic` — dense vector similarity over indexed chunks.
+ * - `keyword`  — exact / tokenized keyword matching.
+ * - `hybrid`   — fused semantic + keyword scores.
+ */
+export type LazykatokSearchMode = "semantic" | "keyword" | "hybrid";
+/**
+ * Configuration for {@link LazykatokClient}. All fields optional; sensible defaults
+ * mirror the jikji client. The client spawns the `lazykatok` binary as a child
+ * process — it never opens the KakaoTalk database directly.
+ */
+export interface LazykatokOptions {
+    /** Explicit path to the `lazykatok` binary. Defaults to a bare `lazykatok` PATH lookup. */
+    readonly binaryPath?: string;
+    /** Spawn timeout in milliseconds. Default 60_000 (sync/index over large archives can be slow). */
+    readonly timeoutMs?: number;
+    /** Max stdout/stderr bytes retained. Default 16 MiB (an `index --json` report alone is multiple MB on a real archive). */
+    readonly maxBufferBytes?: number;
+    /** Explicit native lazykatok data directory, passed as `--data-dir`. */
+    readonly workspacePath?: string;
+    /** Explicit operator-owned configuration/workspace transport. */
+    readonly configPath?: string;
+    /**
+     * Source adapter passed to `sync --source`. Without it the CLI falls back to its
+     * config file, whose default adapter is `fixture` and fails without a JSONL path.
+     * AutoRAG names the live adapter (`macos`) on macOS and passes no flag elsewhere,
+     * so a non-macOS operator's own CLI config still decides; set this to use another
+     * adapter (`kakaocli`, `fixture`, …).
+     */
+    readonly source?: string;
+    /** Environment overrides merged on top of `process.env` for the child. */
+    readonly env?: Readonly<Record<string, string | undefined>>;
+}
+export declare const DEFAULT_LAZYKATOK_BINARY = "lazykatok";
+export declare const DEFAULT_LAZYKATOK_TIMEOUT_MS = 60000;
+/** The live macOS adapter `sync` names by default on darwin. */
+export declare const DEFAULT_LAZYKATOK_SOURCE = "macos";
+export declare const DEFAULT_LAZYKATOK_MAX_BUFFER_BYTES: number;
+export declare const DEFAULT_LAZYKATOK_OPTIONS: {
+    readonly binaryPath: "lazykatok";
+    readonly timeoutMs: 60000;
+    readonly maxBufferBytes: number;
+};
+/**
+ * Reasons a lazykatok CLI invocation can fail. The client never throws for these —
+ * 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";
+/** Common failure payload shared by every method result union. */
+export interface LazykatokFailure {
+    readonly ok: false;
+    readonly reason: LazykatokFailureReason;
+    /** Raw stdout captured (may be partial / empty). Never a binary path. */
+    readonly stdout: string;
+    /** Raw stderr captured (may be partial / empty). Never a binary path. */
+    readonly stderr: string;
+    /** Exit code, or `null` when the process never exited normally. */
+    readonly code: number | null;
+    readonly hits?: readonly unknown[];
+}
+/** A single indexed chat chunk returned by the lazykatok CLI. */
+export interface LazykatokChunk {
+    readonly chunkId: string;
+    readonly content: string;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}
+/** A scored search hit. */
+export interface LazykatokSearchHit {
+    readonly chunkId: string;
+    readonly score: number;
+    readonly content: string;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+    readonly source?: string;
+}
+export type LazykatokHit = LazykatokSearchHit;
+/** Result of `lazykatok doctor`. */
+export interface LazykatokDoctorInfo {
+    readonly version?: string;
+    readonly ready: boolean;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}
+/** Result of `lazykatok sync`. */
+export interface LazykatokSyncInfo {
+    readonly synced: boolean;
+    readonly messageCount?: number;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}
+/** Result of `lazykatok index`. */
+export interface LazykatokIndexInfo {
+    readonly chunkCount: number;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}
+/** Context payload: the chunks surrounding a target chunk. */
+export interface LazykatokContext {
+    readonly chunks: readonly LazykatokChunk[];
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}
+/** Discriminated ok-success shape carrying typed `data`. */
+export interface LazykatokOk<T> {
+    readonly ok: true;
+    readonly data: T;
+    readonly stdout: string;
+    readonly stderr: string;
+    readonly code: number;
+}
+export interface LazykatokSearchOk {
+    readonly ok: true;
+    readonly hits: readonly LazykatokSearchHit[];
+    readonly stdout: string;
+    readonly stderr: string;
+    readonly code: number;
+    readonly data: {
+        readonly hits: readonly LazykatokSearchHit[];
+    };
+}
+export type LazykatokDoctorResult = LazykatokOk<LazykatokDoctorInfo> | LazykatokFailure;
+export type LazykatokSyncResult = LazykatokOk<LazykatokSyncInfo> | LazykatokFailure;
+export type LazykatokIndexResult = LazykatokOk<LazykatokIndexInfo> | LazykatokFailure;
+export type LazykatokSearchResult = LazykatokSearchOk | LazykatokFailure;
+export type LazykatokChunkResult = LazykatokOk<LazykatokChunk> | LazykatokFailure;
+export type LazykatokContextResult = LazykatokOk<LazykatokContext> | LazykatokFailure;
+/** The real `chunk parent --json` payload is a list of parent windows. */
+export type LazykatokParentResult = LazykatokOk<readonly LazykatokChunk[]> | LazykatokFailure;
+/**
+ * Search-specific options. Reuses the shared {@link RetrievalOptions} so the
+ * LazykatokSkill retrieval method can pass its options straight through. The
+ * client maps `topK` to the native CLI limit flag; other fields are handled
+ * by the retrieval layer or are not supported by lazykatok.
+ */
+export type LazykatokSearchOptions = RetrievalOptions;

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

@@ -10,6 +10,8 @@ export declare class MailcrawlClient implements MailcrawlSearchClient {
     constructor(options?: MailcrawlOptions);
     sync(signal?: AbortSignal): Promise<MailcrawlSyncResult>;
     search(mode: MailcrawlSearchMode, query: string, options?: MailcrawlSearchOptions): Promise<MailcrawlSearchResult>;
+    /** `sync`/`index` share the long non-interactive budget. */
+    private indexTimeoutMs;
     private run;
     index(signal?: AbortSignal): Promise<MailcrawlOk<MailcrawlIndexInfo> | MailcrawlFailure>;
 }

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

@@ -13,7 +13,13 @@ export interface MailcrawlOptions {
     readonly source?: string;
     readonly fixture?: string;
     readonly himalayaConfig?: string;
+    /**
+     * Applies to every operation. `sync`/`index` additionally honor
+     * `indexTimeoutMs`, because a 0.2.0 native index run is not interactive.
+     */
     readonly timeoutMs?: number;
+    /** Non-interactive budget for `sync`/`index`; defaults to 30 minutes. */
+    readonly indexTimeoutMs?: number;
     readonly maxBufferBytes?: number;
     readonly env?: Readonly<Record<string, string | undefined>>;
 }
@@ -38,6 +44,12 @@ export interface MailcrawlIndexInfo {
     readonly embedded?: number;
     readonly reused?: number;
     readonly generation?: string;
+    /** 0.2.0 LanceDB index report: archive revision the vectors were built for. */
+    readonly archiveRevision?: string;
+    /** 0.2.0: the store was rebuilt instead of incrementally extended. */
+    readonly rebuilt?: boolean;
+    /** 0.2.0: embedder identity the vectors belong to, e.g. `native:Qwen/Qwen3-Embedding-0.6B:1024`. */
+    readonly embedder?: string;
 }
 export interface MailcrawlSearchHit {
     readonly chunkId: string;

package/dist/datasource/skills/slack/index.d.ts

@@ -2,6 +2,14 @@ import { CrawlerCliClient } from "../../crawler-client.js";
 import { CrawlerDatasourceSkill, type CrawlerDatasourceSkillOptions, type CrawlerSkillClient } from "../../crawler-skill.js";
 import type { CrawlerCliOptions } from "../../crawler-types.js";
 export interface SlacrawlOptions extends CrawlerCliOptions {
+    /**
+     * Slack workspace (team) id to scope reads to, e.g. `T0435JHH63Z`.
+     *
+     * slacrawl's `search`/`messages` read paths return nothing unless a workspace
+     * is named explicitly, even when the archive and its FTS index hold matching
+     * rows, so an unscoped search silently looks like an empty archive.
+     */
+    readonly workspace?: string;
 }
 export declare class SlacrawlClient extends CrawlerCliClient {
     constructor(options?: SlacrawlOptions);

package/dist/datasource/tool-naming.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Canonical model-visible search tool name for one datasource connection.
+ *
+ * The agent generates one `search_datasource_<id>` tool per authorized
+ * connection (see `src/agent/search-single-datasource-tool.ts`), and skill
+ * manifests must be able to name that tool without importing the agent layer
+ * (the import direction is agent → datasource, never the reverse). The alias
+ * rewrite in `aliased-skill.ts` relies on this exact transformation, so keep
+ * it stable: lowercase, non-alphanumerics collapse to `_`, edges trimmed.
+ */
+export declare function datasourceSearchToolName(datasourceId: string): string;

package/dist/datasource/types.d.ts

@@ -2,7 +2,7 @@
  * Datasource core contract.
  *
  * A *datasource* is an external, server-bound source of retrieval evidence
- * (e.g. a KakaoTalk export reached through the external `katok` CLI). The
+ * (e.g. a KakaoTalk export reached through the external `lazykatok` CLI). The
  * datasource layer sits *on top of* the existing retrieval pipeline: it owns
  * access gating and slash-hierarchical source naming, while actual retrieval
  * still flows through {@link RetrievalMethod} instances returned by a skill.
@@ -21,7 +21,7 @@
 import type { RetrievalMethod } from "../retrieval/types.js";
 export type { RetrievalMethod } from "../retrieval/types.js";
 /**
- * Descriptor for a datasource skill (e.g. KakaoTalk via `katok`).
+ * Descriptor for a datasource skill (e.g. KakaoTalk via `lazykatok`).
  *
  * Structurally compatible with {@link RetrievalMethodDescriptor} so that
  * retrieval method descriptors can be gated by the same access context.
@@ -42,7 +42,7 @@ export interface DatasourceSkillDescriptor {
      */
     readonly tags: readonly string[];
     readonly status: "active" | "stub";
-    /** True when the skill shells out to an external CLI (e.g. `katok`). */
+    /** True when the skill shells out to an external CLI (e.g. `lazykatok`). */
     readonly requiresExternalCli?: boolean;
     /**
      * Set when this descriptor describes a datasource-backed surface.
@@ -112,7 +112,7 @@ export interface DatasourceSkillManifest {
 }
 /**
  * A configured, running instance of a datasource skill (e.g. one KakaoTalk
- * account reached through `katok`).
+ * account reached through `lazykatok`).
  */
 export interface DatasourceInstance {
     /** Stable instance id, unique within a skill. */

package/dist/embedding-runtime/manifest.d.ts

@@ -9,6 +9,10 @@ export declare const MODEL_ASSETS: {
         readonly sha256: "06507c7b42688469c4e7298b0a1e16deff06caf291cf0a5b278c308249c3e439";
         readonly license: "Apache-2.0";
         readonly noticeReference: "Qwen3 model card and Apache-2.0 license";
+        readonly intendedUse: "Local loopback embedding for AutoRAG MinSync and native-datasource semantic retrieval. Not a generative model.";
+        readonly unsuitableUse: "Chat or generation, remote embedding of corpus text, shipping weights in the npm package, any GGUF other than the pinned SHA-256.";
+        readonly upstreamCardUrl: "https://huggingface.co/Qwen/Qwen3-Embedding-0.6B";
+        readonly modelCard: "docs/model-cards/qwen3-embedding-0.6b.md";
     };
     readonly embeddinggemma: {
         readonly url: "https://huggingface.co/ggml-org/embeddinggemma-300M-GGUF/resolve/0f741b5a6585bd53aeb15cd1372c56f2a0f65e12/embeddinggemma-300M-Q8_0.gguf";
@@ -16,6 +20,10 @@ export declare const MODEL_ASSETS: {
         readonly sha256: "b5ce9d77a3fc4b3b39ccb5643c36777911cc4eb46a66962eadfa3f5f60490d63";
         readonly license: "Gemma Terms of Use";
         readonly noticeReference: "Google EmbeddingGemma model card and Gemma Terms of Use";
+        readonly intendedUse: "Local loopback embedding for AutoRAG MinSync and native-datasource semantic retrieval. Not a generative model.";
+        readonly unsuitableUse: "Chat or generation, remote embedding of corpus text, shipping weights in the npm package, any GGUF other than the pinned SHA-256, uses restricted by the Gemma Prohibited Use Policy.";
+        readonly upstreamCardUrl: "https://ai.google.dev/gemma/docs/embeddinggemma/model_card";
+        readonly modelCard: "docs/model-cards/embeddinggemma-300m.md";
     };
 };
 export declare const MODEL_ASSET_URLS: {

package/dist/embedding-runtime/types.d.ts

@@ -53,6 +53,10 @@ export interface ModelAsset {
     readonly sha256: string;
     readonly license: string;
     readonly noticeReference: string;
+    readonly intendedUse: string;
+    readonly unsuitableUse: string;
+    readonly upstreamCardUrl: string;
+    readonly modelCard: string;
 }
 export interface RuntimeAsset {
     readonly id: string;