@absolutejs/rag 0.9.0 → 0.11.0

package/dist/src/index.d.ts

@@ -34,3 +34,4 @@ export { corpusTextHash, planRAGCorpus, reconcileRAGCorpus, } from "./retrieval/
 export type { RAGCorpusApply, RAGCorpusDocument, RAGCorpusPlan, RAGCorpusRecord, RAGCorpusResult, RAGCorpusStore, } from "./retrieval/corpus";
 export { chunkRAGOriginalText, readRAGOriginalText, type RAGOriginalText, type RAGOriginalTextLocator, } from "./ingestion/originalText";
 export { createRAGOriginalTextTools, type RAGOriginalTextToolsOptions } from "./retrieval/originalTextTools";
+export { createRAGQuoteReferences } from "./retrieval/quoteReferences";

package/dist/src/retrieval/quoteReferences.d.ts

@@ -0,0 +1,13 @@
+/** A request-scoped, reversible encoding of already-retrieved verbatim quotes.
+ * This is not an authorization mechanism: encode only server-owned tool results,
+ * and reauthorize/revalidate resolved quotes against originals before committing.
+ * Keep one registry across prefetch, subsequent lookups and completion. */
+export declare const createRAGQuoteReferences: () => {
+    /** Accepts the JSON envelopes returned by original-text search/read tools.
+     * Unrecognized results and tool errors pass through unchanged. Source text
+     * is not interpreted as JSON or instructions. Caller retains the originals. */
+    encodeToolResult: (serialized: string) => string;
+    /** Resolve only a reference issued by this registry. A reference from another
+     * request is never loaded from a global cache or used to fetch a source. */
+    resolve: (reference: string) => string;
+};

package/dist/src/web/index.d.ts

@@ -0,0 +1,42 @@
+import { fetchPublicWebResource } from "./transport";
+export { fetchPublicWebResource, validatePublicWebUrl, isPublicWebAddress, WebReadError, } from "./transport";
+export type { WebFetchResult, WebFetchOptions } from "./transport";
+export type WebReadAttempt = {
+    method: "http" | "browser";
+    status: string;
+    httpStatus?: number;
+    extractedChars?: number;
+};
+export type WebReadResult = {
+    status: "ok" | "partial" | "error";
+    url: string;
+    finalUrl: string;
+    title: string | null;
+    text: string;
+    method: "http" | "browser";
+    truncated: boolean;
+    attempts: WebReadAttempt[];
+    error?: {
+        code: string;
+        message: string;
+    };
+    fetchedAt: string;
+};
+export type WebRenderer = (url: string, options: {
+    signal: AbortSignal;
+}) => Promise<{
+    html: string;
+    text?: string;
+    url: string;
+    status: number;
+}>;
+export type ReadWebpageOptions = {
+    url: string;
+    render?: WebRenderer;
+    signal?: AbortSignal;
+    maxChars?: number;
+    mode?: "auto" | "browser";
+    fetchResource?: typeof fetchPublicWebResource;
+};
+/** Read prepared evidence, escalating thin HTML shells to a host-supplied browser. */
+export declare const readRAGWebpage: (options: ReadWebpageOptions) => Promise<WebReadResult>;

package/dist/src/web/playwright.d.ts

@@ -0,0 +1,9 @@
+import type { WebRenderer } from "./index";
+/** Fresh contexts share a browser, never cookies; all HTTP traffic uses pinned public DNS. */
+export declare const createPlaywrightWebRenderer: (options?: {
+    executablePath?: string;
+}) => {
+    render: WebRenderer;
+    ready: () => Promise<void>;
+    close: () => Promise<void>;
+};

package/dist/src/web/transport.d.ts

@@ -0,0 +1,22 @@
+export declare class WebReadError extends Error {
+    code: string;
+    constructor(code: string, message: string);
+}
+export declare const isPublicWebAddress: (address: string) => boolean;
+export type WebFetchResult = {
+    url: string;
+    status: number;
+    headers: Record<string, string>;
+    body: Uint8Array;
+};
+export type WebFetchOptions = {
+    signal?: AbortSignal;
+    redirect?: "follow" | "manual";
+    maxBytes?: number;
+    method?: string;
+    body?: string;
+    headers?: Record<string, string>;
+};
+export declare const validatePublicWebUrl: (raw: string) => URL;
+/** Pin the validated DNS answer into the connection, including every redirect. */
+export declare const fetchPublicWebResource: (raw: string, options?: WebFetchOptions) => Promise<WebFetchResult>;