@cerebriline/core 4.100.245 → 4.100.246

package/dist/extensions/context/capped-thinking.d.ts

@@ -158,6 +158,11 @@ export interface CappedThinkingCondenserConfig {
     /** Absent when no provider is resolved yet; the condenser then stands down. */
     providerConfig?: ProviderConfig;
     summarizer?: CoreCompactionSummarizerConfig;
+    /**
+     * The conversation the notes are written for (`ProviderConfig.sideCallOf`).
+     * Set for the lead only: an agent's note must never close the lead.
+     */
+    sideCallOf?: string;
     logger?: BasicLogger;
 }
 type PrepareTurnResult = {

package/dist/extensions/context/compaction.d.ts

@@ -61,6 +61,12 @@ export interface ContextCompactionPrepareTurnOptions {
      * visibility is. See {@link createCompactionJournal}.
      */
     journal?: CompactionJournal;
+    /**
+     * The conversation the summaries are written for
+     * (`ProviderConfig.sideCallOf`). Set for the lead only: an agent's summary
+     * must never close the lead.
+     */
+    sideCallOf?: string;
 }
 /**
  * The share of the *content* a compaction aims to leave behind.

package/dist/extensions/tools/code-search.d.ts

@@ -37,6 +37,11 @@ export interface CreateCodeSearchOptions {
     getConfig: () => CodeSearchConfig;
     /** @default the shared code index of the data folder */
     index?: CodeIndex;
+    /**
+     * Download LanceDB, which holds the vectors, when it is not installed. For
+     * a host with no panel to offer the download from. @default false
+     */
+    install?: boolean;
     log?: (message: string) => void;
 }
 export interface CodeSearch extends SemanticSearchExecutor {
@@ -53,3 +58,14 @@ export declare function codeSearchAvailable(config: CodeSearchConfig, root: stri
 /** The hits as the model reads them: where each passage is, then the passage. */
 export declare function formatCodeHits(result: CodeSearchResult): string;
 export declare function createCodeSearch(options: CreateCodeSearchOptions): CodeSearch;
+/**
+ * The lead's code search as a delegated agent uses it.
+ *
+ * An agent is built without the lead's executors, so that none of them points
+ * its file tools at the real workspace. This one only reads, and what it reads
+ * for line numbers goes through the agent's own copy of the folder: a passage
+ * in a file the agent has edited is given the lines it is on there.
+ */
+export declare function semanticSearchForAgent(lead: SemanticSearchExecutor | undefined, overlay: {
+    read(path: string): Promise<Buffer>;
+} | undefined): SemanticSearchExecutor | undefined;

package/dist/extensions/tools/library-tools.d.ts

@@ -26,6 +26,20 @@ export interface LibraryScrapeConfig extends ScrapeEndpoint {
     maxPages: number;
     /** How many links deep a crawl follows. */
     maxDepth: number;
+    /**
+     * `false`: every task is offered the general `web_scrape`
+     * (`web-scrape-tool.ts`), which the librarian then uses too. Otherwise
+     * scraping is the librarian's only.
+     */
+    librarianOnly?: boolean;
+    /**
+     * What a site crawl may fetch besides its pages: how many files, how
+     * large one may be and how much in all, in megabytes. Absent, the
+     * defaults of `ScrapeSettings`.
+     */
+    maxFiles?: number;
+    maxFileMb?: number;
+    maxTotalMb?: number;
 }
 export interface LibraryToolsConfig {
     settings: LibrarySettings;

package/dist/extensions/tools/schemas.d.ts

@@ -775,16 +775,7 @@ export type AskQuestionInput = z.infer<typeof AskQuestionInputSchema>;
  * Input for the submit and exit tool
  */
 export type SubmitInput = z.infer<typeof SubmitInputSchema>;
-/**
- * What `grep`, `sed` and `awk` accept, as against what they advertise.
- *
- * The advertised shape keeps `array`, because that is the shape that batches.
- * These wrappers only widen the door: the one field each of them gets wrong is
- * the file list, and it is always wrong the same way. Every other field is the
- * canonical schema's own, so the parsed output is the canonical type already --
- * no pipe back through it, which `z.coerce` fields make ill-typed anyway.
- */
-export declare const GrepInputUnionSchema: z.ZodObject<{
+export declare const GrepInputUnionSchema: z.ZodPreprocess<z.ZodObject<{
     pattern: z.ZodString;
     ignore_case: z.ZodOptional<z.ZodBoolean>;
     invert: z.ZodOptional<z.ZodBoolean>;
@@ -797,7 +788,7 @@ export declare const GrepInputUnionSchema: z.ZodObject<{
     context: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
     max_count: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
     paths: z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodPipe<z.ZodString, z.ZodTransform<string[], string>>]>>;
-}, z.core.$strip>;
+}, z.core.$strip>>;
 export declare const SedInputUnionSchema: z.ZodObject<{
     script: z.ZodString;
     in_place: z.ZodOptional<z.ZodBoolean>;

package/dist/extensions/tools/types.d.ts

@@ -62,7 +62,15 @@ export interface SemanticSearchExecutor {
      * indexed. One host serves many workspaces, so the answer is per folder.
      */
     available(cwd: string): boolean;
-    search(query: string, cwd: string, context: AgentToolContext): Promise<string>;
+    search(query: string, cwd: string, context: AgentToolContext, options?: SemanticSearchOptions): Promise<string>;
+}
+export interface SemanticSearchOptions {
+    /**
+     * Read a file of the folder as the caller sees it, by absolute path. A
+     * delegated agent works on its own copy: the lines a passage is on are the
+     * lines of that copy, not of the lead's file.
+     */
+    readFile?: (absolutePath: string) => Promise<string | undefined>;
 }
 /**
  * Per-call execution options for a shell executor.

package/dist/extensions/tools/web-scrape-tool.d.ts

@@ -0,0 +1,49 @@
+/**
+ * `web_scrape`: the web through a Firecrawl endpoint.
+ *
+ * Two shapes of one tool. The librarian's looks at the web to choose what a
+ * book is made from: search, map, read. The general one is offered to any
+ * task when the user turns "Only for the librarian" off, and adds what a task
+ * outside the Library needs: a crawl that saves a site into the workspace.
+ * By default that is the site itself -- every page as it was served and as
+ * the browser rendered it, with the stylesheets, scripts, pictures and fonts
+ * it uses -- beside a markdown reading of each page; `content: "text"` keeps
+ * the markdown alone, for notes.
+ *
+ * The lead's only: it is not in `DELEGATED_HOST_TOOLS`, so a delegated agent,
+ * whose writes go through its overlay, is never handed a tool that writes to
+ * the workspace directly.
+ */
+import { type AgentTool } from "@cerebriline/shared";
+import type { LibraryScrapeConfig } from "./library-tools";
+export { cleanLink, linkCensus, pageFileName } from "./web-site-crawl";
+export declare const WEB_SCRAPE_TOOL_NAME = "web_scrape";
+export declare const NO_SCRAPER = "Web scraping is not set up for this session. The user sets the endpoint under Settings > Features and allows it in the API configuration; do not call this again in this task.";
+export interface WebScrapeToolOptions {
+    /** The folder saved pages are written under. */
+    cwd: string;
+    /** The endpoint and its limits, read on every call. Undefined: not set up. */
+    getScrape: () => LibraryScrapeConfig | undefined;
+    /** What stops the tool before the endpoint is asked, said to the model. */
+    unavailable?: () => string | undefined;
+    /** The general tool: `crawl`, and `save_to`. @default false, the librarian's */
+    general?: boolean;
+    onError?: (message: string, error: unknown) => void;
+    /**
+     * A text file the tool wrote, by absolute path. The host forgets what it
+     * knew of the file, so a later read is not told that something outside the
+     * session changed it.
+     */
+    onWrote?: (file: string) => void;
+}
+/** `target` under `cwd`, or nothing when it would leave the folder. */
+export declare function workspacePath(cwd: string, target: string): string | undefined;
+export declare function createWebScrapeTool(options: WebScrapeToolOptions): AgentTool;
+/**
+ * The general tool, when scraping is set up, allowed, and not kept for the
+ * librarian. Decided at session start, like every other tool list; the
+ * endpoint itself is read again on every call.
+ */
+export declare function createWebScrapeTools(options: Omit<WebScrapeToolOptions, "general"> & {
+    log?: (message: string) => void;
+}): AgentTool[];

package/dist/extensions/tools/web-site-crawl.d.ts

@@ -0,0 +1,96 @@
+/**
+ * A site crawled into a folder of the workspace, and continued later.
+ *
+ * The folder keeps a record of the crawl (`.scrape.json`): the pages read
+ * and where each was saved, the files fetched, the pages that are linked and
+ * were not read, and the files a limit left out. A later crawl into the same
+ * folder with `resume` reads only what is missing -- the pages from that
+ * list, one by one through the endpoint, and the files not yet on disk --
+ * and nothing that is already there.
+ *
+ * Every limit that stopped something is said at the top of the result, as an
+ * alert the model is told to pass on: the user set those limits, and only
+ * the user can raise them.
+ */
+import { type ScrapedPage } from "../../services/retrieval/firecrawl";
+import type { LibraryScrapeConfig } from "./library-tools";
+export declare function plural(count: number, one: string, many?: string): string;
+/** An http(s) address without its fragment, or nothing. */
+export declare function cleanLink(link: string): string | undefined;
+/**
+ * A page's file under the crawl's folder: its host and path, with what a
+ * file name cannot hold replaced, so two pages of a site never collide and
+ * the folder reads like the site.
+ */
+export declare function pageFileName(url: string, taken: Set<string>): string;
+export declare function pageFile(page: ScrapedPage): string;
+/**
+ * Where the links of the pages read lead: pages of the same site that were
+ * not read, and other sites. It is what tells "the site has no more pages"
+ * from "the crawl stopped short" -- the two read the same from a page count.
+ */
+export declare function linkCensus(pages: readonly ScrapedPage[], start: string): {
+    unread: string[];
+    elsewhere: string[];
+};
+export declare function sitesLine(hosts: readonly string[], most?: number): string;
+/** The record a crawl leaves in its folder. */
+export declare const SITE_RECORD_FILE = ".scrape.json";
+export interface SiteRecord {
+    version: 1;
+    /** The address the crawl started from. */
+    url: string;
+    content: "site" | "text";
+    wholeSite: boolean;
+    include: string[];
+    exclude: string[];
+    /** Pages read, by address. */
+    pages: Record<string, {
+        title?: string;
+        markdown: string;
+        characters: number;
+        served?: string;
+        rendered?: string;
+    }>;
+    /** Files fetched, by address. */
+    assets: Record<string, {
+        file: string;
+        bytes: number;
+    }>;
+    /** Pages of the site that are linked and were not read. */
+    unread: string[];
+    /** Files a limit left out. */
+    assetsLeft: string[];
+    /** Files that could not be fetched, with the reason. */
+    failed: Record<string, string>;
+    /** Pages that could not be read, with the reason. */
+    failedPages: Record<string, string>;
+}
+export interface CrawlToFolderRequest {
+    scrape: LibraryScrapeConfig;
+    url: string;
+    /** The folder, absolute. */
+    target: string;
+    /** The folder as the model named it, for the result. */
+    folder: string;
+    limit?: number;
+    depth?: number;
+    include: string[];
+    exclude: string[];
+    wholeSite?: boolean;
+    content?: "site" | "text";
+    resume: boolean;
+    signal?: AbortSignal;
+    emit?: (status: string) => void;
+    /** A text file the crawl wrote or rewrote, by absolute path. */
+    wrote?: (file: string) => void;
+    /** The crawl stopped at a limit of the user's; see `reportStoppedForUser`. */
+    stopped?: (reason: string) => void;
+}
+/**
+ * Whether a link is one this crawl reads: the same site, below the starting
+ * address unless the whole site was asked for, and through the path filters.
+ */
+export declare function inCrawlScope(link: string, record: Pick<SiteRecord, "url" | "wholeSite" | "include" | "exclude">): boolean;
+/** Crawl a site into a folder, or continue the crawl that is there. */
+export declare function crawlToFolder(request: CrawlToFolderRequest): Promise<string>;