@autorag/librarian 2.10.0 → 2.10.1

package/dist/agent/agent.d.ts

@@ -1,5 +1,5 @@
 import type { Agent, AgentTool } from "@earendil-works/pi-agent-core";
-import type { Api, Model } from "@earendil-works/pi-ai";
+import type { Api, ImageContent, Model } from "@earendil-works/pi-ai";
 import type { DatasourceIndexResult, DatasourceSkill } from "../datasource/types.js";
 import { type DupeyCliOptions } from "../dupey/index.js";
 import { type Embedder } from "../embedding-runtime/gateway-embedder.js";
@@ -356,6 +356,16 @@ export declare class AutoRAGAgent {
     private lastQuery;
     private lastSessionId;
     private activeRun;
+    /**
+     * Steering state of the running search. A TUI query runs detached from pi's
+     * input loop (pi reads the next input only after its input handler returns),
+     * so input typed meanwhile steers this run (Enter) or waits behind it
+     * (Alt+Enter), the way pi steers its own turns. {@link steer} feeds the same
+     * state for `searchDocuments()` / `searchDocumentsStream()` callers.
+     */
+    private readonly interactive;
+    /** Aborted by {@link abort} and by the run's timeout: gates publishing and the run's own requests. */
+    private activeRunAbort;
     private modelNativeSearchAuth;
     private retrievalTrace;
     /** Evidence every retrieval tool returned this run; the answer's inline `[eN]` citations resolve against it. */
@@ -470,8 +480,36 @@ export declare class AutoRAGAgent {
     private currentSystemPromptConfig;
     subscribe(listener: Parameters<Agent["subscribe"]>[0]): () => void;
     createPiInteractiveRuntime(): Promise<AutoRAGPiInteractiveRuntime>;
+    /**
+     * The session's custom tools, with retrieval and web reads interruptible by a
+     * steer: stopping them loses no side effect. bash and the file tools are pi
+     * built-ins and never pass through here.
+     */
+    private steerableTools;
+    /**
+     * Lets a steer cut a retrieval tool short, like an interruptible wait in pi:
+     * the tool's signal also aborts on the steer, and the call resolves at once
+     * with a skipped result telling the model to retry if the search still
+     * matters, so the steer reaches the model before the next request.
+     */
+    private interruptibleBySteer;
     /** Resolve the model's inline `[eN]` citations against this run's evidence and derive the structured results. */
     private deriveAnswer;
+    /**
+     * Routes one TUI input the way pi routes typed input for its own turns. With
+     * no search running it starts one. During a search, Enter steers it (the
+     * user is correcting a search that is going wrong) and Alt+Enter queues a
+     * follow-up question that runs once this search answers.
+     */
+    private routeInteractiveInput;
+    /**
+     * Esc and Alt+Enter during a search. pi handles both itself while a turn
+     * streams (abort, queue follow-up); between phases it ignores Esc and submits
+     * Alt+Enter like Enter, so AutoRAG acts on them there.
+     */
+    private handleInteractiveKey;
+    /** Runs one TUI query detached from pi's input loop, then any follow-ups queued behind it. */
+    private startInteractiveQuery;
     /**
      * Drives one TUI query through the two-phase search. The model's own
      * assistant messages (progress notes before a tool call, the fast answer,
@@ -480,7 +518,31 @@ export declare class AutoRAGAgent {
      * twice and put it in the model's context twice.
      */
     private runInteractivePiQuery;
+    /** Resolves once the TUI search and every follow-up queued behind it finished. */
+    waitForIdle(): Promise<void>;
+    /**
+     * Steers the running `searchDocuments()` / `searchDocumentsStream()` search,
+     * the way Enter steers a TUI search: `text` is a correction of the search in
+     * progress, not a new question. It reaches the search's next model request
+     * (also between phases, where no turn streams), cuts in-flight retrieval and
+     * the baseline prefetch short so it lands promptly, and forces the
+     * verification phase, whose prompt restates it. A steer that lands after
+     * verification's last request gets one more verification turn in the same
+     * search. The final answer stays the answer to the original question.
+     *
+     * Returns false, and does nothing, when no search is running, the search was
+     * stopped, or it is past its last model request; the caller should then ask
+     * the text as a new question.
+     */
+    steer(text: string, images?: readonly ImageContent[]): boolean;
+    /**
+     * Stops the running search as a whole: the streaming model turn, the
+     * baseline prefetch, in-flight retrieval, and every later phase. The search
+     * then resolves without a verified answer.
+     */
     abort(): void;
+    /** The next model request took the queued steers into the transcript; later retrieval runs uninterrupted until the next steer. */
+    private steersReachedModel;
     /**
      * Periodically re-runs the incremental {@link refresh} so parsed mirrors and
      * indexes stay current. Re-parsing is incremental (mtime/size) via the
@@ -604,7 +666,7 @@ export declare class AutoRAGAgent {
      * against it; the model then verifies with thinking on and ends with the
      * final answer as a plain reply, returning only the delta.
      */
-    buildRefinementPrompt(query: string, options: RetrievalOptions, fastAnswer: string | undefined, fastAnswerDelivered: boolean): string;
+    buildRefinementPrompt(query: string, options: RetrievalOptions, fastAnswer: string | undefined, fastAnswerDelivered: boolean, steers?: readonly string[]): string;
     buildSearchPrompt(query: string, options: RetrievalOptions, initialRetrievalContext?: string): string;
     refresh(force?: boolean, opts?: AutoRAGRefreshOptions): Promise<AutoRAGRefreshResult>;
     /**
@@ -679,6 +741,7 @@ export declare class AutoRAGAgent {
     findJikji(query: string, opts?: {
         readonly topK?: number;
         readonly first?: boolean;
+        readonly signal?: AbortSignal;
     }): Promise<JikjiFindProviderResult>;
     /**
      * Merge per-root answer packs into one. Concatenates answer_paths/candidates
@@ -723,6 +786,7 @@ export declare class AutoRAGAgent {
     searchAllDocuments(query: string, options?: {
         readonly topK?: number;
         readonly scope?: string;
+        readonly signal?: AbortSignal;
     }): Promise<{
         results: RetrievalResult[];
         diagnostics: RetrievalDiagnostic[];
@@ -740,6 +804,7 @@ export declare class AutoRAGAgent {
     searchSingleDatasourceDocuments(datasourceId: string, query: string, options?: {
         readonly topK?: number;
         readonly scope?: string;
+        readonly signal?: AbortSignal;
     }): Promise<{
         results: RetrievalResult[];
         diagnostics: RetrievalDiagnostic[];

package/dist/agent/context-token-guard.d.ts

@@ -0,0 +1,23 @@
+import type { AgentMessage } from "@earendil-works/pi-agent-core";
+import type { Model } from "@earendil-works/pi-ai";
+type ContextTokenGuardModel = Model<any> | (() => Model<any> | undefined) | undefined;
+/**
+ * Compose an optional context transform with the aggregate token guard. The
+ * guard runs on the final transcript immediately before each provider request,
+ * so it sees the system prompt, tool declarations, user query, memory context,
+ * and every prior tool result.
+ */
+export declare function createContextTokenGuardedTransform(model: ContextTokenGuardModel, base?: (messages: AgentMessage[]) => Promise<AgentMessage[]>, fixedOverheadTokens?: () => number): (messages: AgentMessage[]) => Promise<AgentMessage[]>;
+/**
+ * Keep complete retrieval candidates while the assembled request fits the
+ * model budget. Removing a per-chunk cut is only safe because this drops whole
+ * lower-ranked candidates (with an explicit marker) instead of hiding text.
+ */
+export declare function guardAgentContextMessages(model: Model<any> | undefined, messages: AgentMessage[], useReportedUsage?: boolean, fixedOverheadTokens?: number): AgentMessage[];
+/**
+ * Estimate the current transcript with pi-coding-agent's conservative chars/4
+ * counter. `useReportedUsage` adds the last assistant turn's provider-reported
+ * usage for the settled prefix; pass false when the messages were just edited.
+ */
+export declare function estimateContextMessageTokens(messages: readonly AgentMessage[], useReportedUsage?: boolean): number;
+export {};

package/dist/agent/jev-extension.d.ts

@@ -4,9 +4,10 @@ import { type JevBackend, type Judgment, type Question, type State } from "jev-u
 export declare const JEV_TOOL_NAME = "jev";
 /**
  * Jev backends the `jev-use` engine resolves from the environment, in
- * auto-select order: TypeSafe -> OpenRouter -> Vercel AI Gateway.
+ * auto-select order: TypeSafe -> OpenRouter -> Vercel AI Gateway. `autorag` is
+ * the hosted AutoRAG (Dazzi) plan, built here rather than resolved by jev-use.
  */
-export type JevBackendName = "typesafe" | "openrouter" | "vercel";
+export type JevBackendName = "typesafe" | "openrouter" | "vercel" | "autorag";
 /**
  * OpenRouter's live Jev model id. `jev-use` 0.8.0 ships `typesafe/jev-latest`,
  * which OpenRouter rejects with HTTP 400 ("Model ... does not exist"), so the
@@ -51,8 +52,8 @@ export type JevJudge = (state: State, questions: Question[], options?: {
 /**
  * Builds the Jev judge shared by the `jev` tool and the query router. The
  * `jev-use` client is created lazily on the first call, so no credential
- * resolves at construction time, and the OpenRouter model pin applies to
- * every caller.
+ * resolves at construction time, and the per-backend model default (the
+ * OpenRouter pin, or `jev-1.13` on the hosted plan) applies to every caller.
  */
 export declare function createJevJudge(options?: JevJudgeOptions): JevJudge;
 /**

package/dist/agent/jikji-find-tool.d.ts

@@ -44,6 +44,7 @@ export interface JikjiFindProvider {
     findJikji(query: string, opts?: {
         readonly topK?: number;
         readonly first?: boolean;
+        readonly signal?: AbortSignal;
     }): Promise<JikjiFindProviderResult>;
 }
 export interface JikjiFindDetails {

package/dist/agent/pi-session.d.ts

@@ -1,5 +1,5 @@
 import type { AgentMessage, AgentTool } from "@earendil-works/pi-agent-core";
-import type { Api, Model } from "@earendil-works/pi-ai";
+import type { Api, ImageContent, Model } from "@earendil-works/pi-ai";
 import { type AgentSession, type AgentSessionRuntime, type ExtensionAPI, type ExtensionFactory, SettingsManager, type ToolDefinition, type TuiMode } from "@earendil-works/pi-coding-agent";
 export declare const PI_BUILTIN_TOOL_NAMES: readonly ["read", "bash", "edit", "write", "grep", "find", "ls"];
 /**
@@ -34,10 +34,43 @@ export interface AutoRAGPiSessionOptions {
     readonly remoteSession?: boolean;
     readonly contextTransform?: (messages: AgentMessage[]) => Promise<AgentMessage[]>;
 }
+/**
+ * How AutoRAG takes one interactive input. `steer` while a pi turn streams
+ * returns the text pi should queue as steering (pi delivers it before the
+ * turn's next model request); every other outcome is fully handled by AutoRAG.
+ */
+export type AutoRAGInputDisposition = {
+    readonly kind: "handled";
+} | {
+    readonly kind: "steer";
+    readonly text: string;
+};
+export interface AutoRAGInteractiveInput {
+    readonly text: string;
+    readonly images: readonly ImageContent[] | undefined;
+    /** pi's delivery for input typed while a turn streams; undefined when no turn streams. */
+    readonly streamingBehavior: "steer" | "followUp" | undefined;
+}
+/** A TUI key AutoRAG acts on itself while a search runs, even when no pi turn streams. */
+export type AutoRAGInteractiveKey = "interrupt" | "followUp";
 export interface AutoRAGPiInteractiveRuntimeOptions extends Omit<AutoRAGPiSessionOptions, "model"> {
     readonly model?: Model<Api>;
     readonly inactiveToolNames?: readonly string[];
-    readonly onQuery: (query: string, pi: ExtensionAPI) => void | Promise<void>;
+    /**
+     * Routes one interactive input: a new query, a steer of the running search,
+     * or a follow-up queued behind it. Must not wait for a search to finish:
+     * pi's TUI reads the next input only after this returns.
+     */
+    readonly onInput: (input: AutoRAGInteractiveInput, pi: ExtensionAPI) => AutoRAGInputDisposition;
+    /** Whether a search is running: while it is, every interactive input belongs to it. */
+    readonly isSearchRunning?: () => boolean;
+    /**
+     * Called for pi's interrupt (Esc) and follow-up (Alt+Enter) keys while a
+     * search runs. pi acts on them only while a turn streams, but a search also
+     * spends time between turns (routing, prefetch, checks). Return true to
+     * consume the key; pi then never sees it.
+     */
+    readonly onKey?: (key: AutoRAGInteractiveKey) => boolean;
     /**
      * Optional best-effort provider for a startup update notice. Resolves to the
      * notice text, or `undefined` when there is nothing to announce. Called once

package/dist/agent/request-limits.d.ts

@@ -0,0 +1,20 @@
+import type { AgentMessage } from "@earendil-works/pi-agent-core";
+import type { ModelInputLimits } from "@earendil-works/pi-ai";
+/** Stands in for an image dropped from a model request by {@link fitRequestLimits}. */
+export declare const IMAGE_OMITTED_NOTE = "[Image omitted from this request to stay within the model provider's request limits. Read the file again if you still need to see it.]";
+/**
+ * Fits a model request into the provider's declared `inputLimits`.
+ *
+ * pi keeps every image a tool returned in the transcript and resends all of
+ * them on each later turn, but it never enforces `maxRequestBytes` or
+ * `images.maxPerRequest`. A search that reads a handful of photos therefore
+ * grows past a provider's body limit and the request fails outright (the hosted
+ * AutoRAG API answers HTTP 413). Images are what grows the body, so the oldest
+ * ones are replaced with {@link IMAGE_OMITTED_NOTE} until the request fits; the
+ * newest images, which the model is looking at, go last. Text is never touched.
+ *
+ * The size is the serialized transcript, a close lower bound of the provider
+ * body, so `maxRequestBytes` should keep headroom below the hard limit.
+ * Returns undefined when the request already fits; never mutates `messages`.
+ */
+export declare function fitRequestLimits(messages: readonly AgentMessage[], limits: ModelInputLimits | undefined): AgentMessage[] | undefined;

package/dist/agent/search-all-tool.d.ts

@@ -18,6 +18,7 @@ export interface SearchAllDocumentsProvider {
     searchAllDocuments(query: string, options?: {
         readonly topK?: number;
         readonly scope?: string;
+        readonly signal?: AbortSignal;
     }): Promise<SearchAllDocumentsResult>;
 }
 export interface SearchAllDocumentsDetails {

package/dist/agent/search-single-datasource-tool.d.ts

@@ -39,6 +39,7 @@ export interface SingleDatasourceSearchProvider {
     searchSingleDatasourceDocuments(datasourceId: string, query: string, options?: {
         readonly topK?: number;
         readonly scope?: string;
+        readonly signal?: AbortSignal;
     }): Promise<{
         readonly results: readonly RetrievalResult[];
         readonly diagnostics: readonly RetrievalDiagnostic[];

package/dist/cli/config.d.ts

@@ -55,13 +55,14 @@ export interface WebSearchCliConfig {
 }
 /**
  * Jev decision-tool config. Absent disables the tool; `enabled: false` disables
- * it explicitly. Secrets never appear here: the `jev-use` engine reads the
- * backend credential from its own environment variable (`TYPESAFE_API_KEY`,
- * `OPENROUTER_API_KEY`, or `AI_GATEWAY_API_KEY`).
+ * it explicitly. Secrets never appear here: `jev-use` reads the backend
+ * credential from its own environment variable (`TYPESAFE_API_KEY`,
+ * `OPENROUTER_API_KEY`, or `AI_GATEWAY_API_KEY`), and the hosted AutoRAG
+ * `autorag` backend reads `AUTORAG_API_KEY`.
  */
 export interface JevCliConfig {
     enabled?: boolean;
-    /** Force one backend; omit to let the first credential present win. */
+    /** Force one backend (`openrouter`, `typesafe`, `vercel`, or `autorag`); omit to let the first credential present win. */
     backend?: JevBackendName;
     /** Model id sent with every call, e.g. `jev-latest`. */
     model?: string;
@@ -75,20 +76,21 @@ export interface QueryDecompositionConfig {
 }
 /**
  * Post-merge reranking config. Routes merged evidence through a dedicated
- * rerank model. `provider` is `openrouter` today; `model` is the OpenRouter
- * wire id (default `voyageai/rerank-3-lite`). Secrets never appear here — only
- * the environment-variable name that holds the provider API key.
+ * rerank model. `provider` is `openrouter` (default) or the hosted AutoRAG
+ * plan (`autorag`); each provider supplies its own default `model` and
+ * `apiKeyEnv`. Secrets never appear here — only the environment-variable name
+ * that holds the provider API key.
  */
 export interface RerankConfig {
     /** `false` disables reranking. Missing means enabled when the block is present. */
     enabled?: boolean;
-    /** Provider id. @default "openrouter" */
+    /** Provider id (`openrouter` or `autorag`). @default "openrouter" */
     provider?: string;
-    /** Wire model id. @default "voyageai/rerank-3-lite" */
+    /** Wire model id. @default "voyageai/rerank-3-lite" (`openrouter`) / "qwen/qwen3-reranker-8b" (`autorag`) */
     model?: string;
-    /** Environment variable holding the provider API key. @default "OPENROUTER_API_KEY" */
+    /** Environment variable holding the provider API key. @default "OPENROUTER_API_KEY" (`openrouter`) / "AUTORAG_API_KEY" (`autorag`) */
     apiKeyEnv?: string;
-    /** Override the provider base URL (e.g. a gateway). */
+    /** Override the provider base URL (e.g. a gateway); for `autorag`, the API base including `/v1`. */
     baseUrl?: string;
     /** Return only the top N merged results. @default 25 (DEFAULT_RERANK_TOP_N) */
     topN?: number;