@ontos-ai/knowhere-sdk 0.6.0 → 0.8.0

package/dist/index.d.ts

@@ -3,12 +3,15 @@ import { Agent as Agent$1 } from 'https';
 import { ReadStream } from 'fs';
 import { AxiosRequestConfig, AxiosInstance } from 'axios';
 
+type AuthTokenProvider = () => string | Promise<string>;
 /**
  * Configuration options for the Knowhere client
  */
 interface KnowhereOptions {
     /** API authentication key (defaults to KNOWHERE_API_KEY env var) */
     apiKey?: string;
+    /** Dynamic bearer token provider for short-lived non-API-key auth flows */
+    authTokenProvider?: AuthTokenProvider;
     /** API base URL (defaults to https://api.knowhereto.ai) */
     baseURL?: string;
     /** Request timeout in milliseconds (default: 60000) */
@@ -43,6 +46,8 @@ interface Job {
     dataId?: string;
     /** Retrieval namespace for the canonical document */
     namespace?: string;
+    /** Planned stable document identifier for this job, when returned by the API */
+    documentId?: string;
     /** Job creation timestamp */
     createdAt: Date;
     /** Presigned URL for file upload (if sourceType is 'file') */
@@ -151,6 +156,10 @@ interface WebhookConfig {
     /** Webhook URL to notify on job completion */
     url: string;
 }
+/**
+ * Client-provided display metadata copied onto the published document.
+ */
+type DocumentMetadata = Record<string, unknown>;
 /**
  * Job creation parameters
  */
@@ -167,6 +176,8 @@ interface CreateJobParams {
     namespace?: string;
     /** Existing document identifier when updating a published document */
     documentId?: string;
+    /** Display metadata to copy onto the published document */
+    documentMetadata?: DocumentMetadata;
     /** Parsing configuration */
     parsingParams?: ParsingParams;
     /** Webhook configuration */
@@ -233,6 +244,8 @@ interface ParseParams {
     namespace?: string;
     /** Existing document identifier when updating a published document */
     documentId?: string;
+    /** Display metadata to copy onto the published document */
+    documentMetadata?: DocumentMetadata;
     /** Additional fragment description */
     addFragDesc?: string;
     /** Knowledge base directory */
@@ -520,7 +533,8 @@ interface ParseResult {
 
 interface HttpClientOptions {
     baseURL: string;
-    apiKey: string;
+    apiKey?: string;
+    authTokenProvider?: AuthTokenProvider;
     timeout?: number;
     uploadTimeout?: number;
     maxRetries?: number;
@@ -537,8 +551,10 @@ declare class HttpClient {
     private uploadTimeout;
     private httpAgent?;
     private httpsAgent?;
+    private authTokenProvider?;
     constructor(options: HttpClientOptions);
     private setupInterceptors;
+    private attachDynamicAuthorization;
     private handleError;
     private getErrorObject;
     private normalizeErrorData;
@@ -774,6 +790,8 @@ interface Document {
     currentJobResultId?: string;
     /** Original source file name */
     sourceFileName?: string;
+    /** Client-provided display metadata copied from the publishing job */
+    documentMetadata?: Record<string, unknown>;
     /** Document creation timestamp */
     createdAt?: Date;
     /** Last update timestamp */
@@ -919,6 +937,234 @@ declare class Documents extends BaseResource {
     private createChunkGetRequestConfig;
 }
 
+type KnowledgeChunkType = DocumentChunkType;
+interface KnowledgeParseParams extends ParseParams {
+    /** Optional stable local identifier for this parsed result copy. */
+    localDocumentId?: string;
+}
+interface LocalKnowledgeDocument {
+    /** Stable local identifier used by local outline/read/grep methods. */
+    localDocumentId: string;
+    /** Server parse job identifier. */
+    jobId: string;
+    /** Server canonical document identifier when publication returned one. */
+    documentId?: string;
+    /** Server retrieval namespace when available. */
+    namespace?: string;
+    /** Original source file name from the parse manifest. */
+    sourceFileName: string;
+    /** Number of chunks in the locally cached parse result. */
+    chunkCount: number;
+    /** Chunk counts grouped by type. */
+    typeCounts: Record<KnowledgeChunkType, number>;
+    /** Local cache directory containing expanded Knowhere result files and assets. */
+    resultDirectoryPath: string;
+    /** Cache creation time. */
+    createdAt: Date;
+    /** Last cache write time. */
+    updatedAt: Date;
+}
+interface LocalKnowledgeParseResponse {
+    document: LocalKnowledgeDocument;
+    result: ParseResult;
+}
+interface KnowledgeAsyncParseParams extends ParseParams {
+    /** Optional stable local identifier to use when this job result is cached later. */
+    localDocumentId?: string;
+}
+interface KnowledgeAsyncParseResponse {
+    job: Job;
+    localDocumentId?: string;
+}
+type KnowledgeAsyncCacheStatus = 'pending' | 'cached' | 'already_cached' | 'untracked' | 'not_available' | 'failed';
+interface KnowledgeAsyncCacheResult {
+    status: KnowledgeAsyncCacheStatus;
+    localDocumentId?: string;
+    document?: LocalKnowledgeDocument;
+    error?: string;
+}
+interface KnowledgeAsyncJobStatusResponse {
+    job: JobResult;
+    cache: KnowledgeAsyncCacheResult;
+}
+interface KnowledgeStartupRecoveryResponse {
+    checkedJobs: number;
+    results: KnowledgeAsyncJobStatusResponse[];
+}
+interface KnowledgeCacheJobResultParams {
+    jobId: string;
+    localDocumentId?: string;
+    verifyChecksum?: boolean;
+}
+interface KnowledgeSection {
+    sectionPath: string;
+    sectionTitle: string;
+    sectionLevel: number;
+    summary?: string;
+    startChunk?: number;
+    endChunk?: number;
+    chunkCount: number;
+    typeCounts: Record<KnowledgeChunkType, number>;
+    children: KnowledgeSection[];
+}
+interface KnowledgeOutline {
+    document: LocalKnowledgeDocument;
+    totalChunks: number;
+    typeCounts: Record<KnowledgeChunkType, number>;
+    sections: KnowledgeSection[];
+    sectionTree: KnowledgeSection[];
+}
+interface KnowledgeReadParams {
+    localDocumentId: string;
+    sectionPath?: string;
+    startChunk?: number;
+    endChunk?: number;
+    chunkId?: string;
+    chunkType?: KnowledgeChunkType;
+    limit?: number;
+}
+interface KnowledgeReadChunk {
+    position: number;
+    chunkId: string;
+    chunkType: KnowledgeChunkType;
+    content: string;
+    sectionPath: string;
+    sourceChunkPath: string;
+    filePath?: string;
+    metadata: Record<string, unknown>;
+}
+interface KnowledgeReadResponse {
+    document: LocalKnowledgeDocument;
+    chunks: KnowledgeReadChunk[];
+    nextChunk?: number;
+}
+interface KnowledgeGrepParams {
+    localDocumentId: string;
+    pattern: string;
+    isRegex?: boolean;
+    isCaseSensitive?: boolean;
+    maxResults?: number;
+    chunkType?: KnowledgeChunkType;
+    sectionPathPrefix?: string;
+    contextChars?: number;
+}
+interface KnowledgeGrepMatch {
+    position: number;
+    chunkId: string;
+    chunkType: KnowledgeChunkType;
+    sectionPath: string;
+    sourceChunkPath: string;
+    filePath?: string;
+    startOffset: number;
+    endOffset: number;
+    snippet: string;
+}
+interface KnowledgeGrepResponse {
+    document: LocalKnowledgeDocument;
+    matches: KnowledgeGrepMatch[];
+    scannedChunks: number;
+    truncated: boolean;
+}
+interface KnowledgeSearchParams {
+    query: string;
+    namespace?: string;
+    topK?: number;
+    localDocumentIds?: string[];
+    useAgentic?: boolean;
+}
+interface KnowledgeSearchReference {
+    localDocumentId?: string;
+    documentId?: string;
+    chunkId?: string;
+    sectionPath?: string;
+    chunkType?: string;
+    score?: number | null;
+}
+interface KnowledgeSearchResponse {
+    namespace?: string;
+    query: string;
+    evidenceText?: string | null;
+    references: KnowledgeSearchReference[];
+    results: KnowledgeSearchResult[];
+    rawResponse: unknown;
+}
+interface KnowledgeSearchResult {
+    localDocumentId?: string;
+    documentId?: string;
+    chunkId?: string;
+    chunkType?: string;
+    content: string;
+    score: number | null;
+    sectionPath?: string;
+    sourceFileName?: string;
+}
+
+declare class Knowledge {
+    private readonly client;
+    private readonly store;
+    constructor(client: Knowhere, options?: {
+        cacheDirectory?: string;
+    });
+    withCacheDirectory(cacheDirectory: string): Knowledge;
+    parse(params: KnowledgeParseParams): Promise<LocalKnowledgeParseResponse>;
+    startParse(params: KnowledgeAsyncParseParams): Promise<KnowledgeAsyncParseResponse>;
+    getJobStatus(jobId: string): Promise<KnowledgeAsyncJobStatusResponse>;
+    recoverPendingAsyncParseJobs(): Promise<KnowledgeStartupRecoveryResponse>;
+    cacheJobResult(params: KnowledgeCacheJobResultParams): Promise<LocalKnowledgeParseResponse>;
+    private resolveAsyncCache;
+    listDocuments(): Promise<LocalKnowledgeDocument[]>;
+    getDocumentOutline(localDocumentId: string): Promise<KnowledgeOutline>;
+    readChunks(params: KnowledgeReadParams): Promise<KnowledgeReadResponse>;
+    grepChunks(params: KnowledgeGrepParams): Promise<KnowledgeGrepResponse>;
+    search(params: KnowledgeSearchParams): Promise<KnowledgeSearchResponse>;
+    private resolveSearchDocuments;
+}
+
+interface StoredAsyncParseJob {
+    jobId: string;
+    localDocumentId?: string;
+    cacheStatus: KnowledgeAsyncCacheStatus;
+    createdAt: string;
+    updatedAt: string;
+}
+interface LocalKnowledgeAsyncParseJob {
+    jobId: string;
+    localDocumentId?: string;
+    cacheStatus: KnowledgeAsyncCacheStatus;
+    createdAt: Date;
+    updatedAt: Date;
+}
+declare class LocalKnowledgeStore {
+    private readonly cacheDirectory;
+    private readonly indexPath;
+    private readonly resultCache;
+    constructor(cacheDirectory?: string);
+    saveResult(result: ParseResult, options?: {
+        localDocumentId?: string;
+    }): Promise<LocalKnowledgeDocument>;
+    saveAsyncParseJob(params: {
+        jobId: string;
+        localDocumentId?: string;
+    }): Promise<void>;
+    getAsyncParseJob(jobId: string): Promise<StoredAsyncParseJob | undefined>;
+    listRecoverableAsyncParseJobs(): Promise<LocalKnowledgeAsyncParseJob[]>;
+    updateAsyncParseJobCacheStatus(params: {
+        jobId: string;
+        cacheStatus: KnowledgeAsyncCacheStatus;
+        localDocumentId?: string;
+    }): Promise<void>;
+    listDocuments(): Promise<LocalKnowledgeDocument[]>;
+    getDocument(localDocumentId: string): Promise<LocalKnowledgeDocument | undefined>;
+    loadResult(localDocumentId: string): Promise<{
+        document: LocalKnowledgeDocument;
+        result: ParseResult;
+    }>;
+    private getResultDirectoryPath;
+    private loadStoredResult;
+    private readIndex;
+    private writeIndex;
+}
+
 /**
  * Main Knowhere SDK client
  */
@@ -929,6 +1175,8 @@ declare class Knowhere {
     readonly retrieval: Retrieval;
     /** Documents resource for canonical document lifecycle operations */
     readonly documents: Documents;
+    /** Client-side local knowledge tools over parsed Knowhere results */
+    readonly knowledge: Knowledge;
     private httpClient;
     /**
      * Create a new Knowhere client
@@ -955,6 +1203,12 @@ declare class Knowhere {
      * ```
      */
     parse(params: ParseParams): Promise<ParseResult>;
+    /**
+     * Start a parse job and return immediately after the URL job is created or
+     * the local file is uploaded. Use jobs.get()/jobs.wait() and jobs.load()
+     * to inspect completion and load results later.
+     */
+    startParse(params: ParseParams): Promise<Job>;
 }
 
 declare const VERSION = "0.1.0";
@@ -1088,4 +1342,4 @@ declare class JobFailedError extends KnowhereError {
     constructor(message: string, code: string, jobResult: JobResult);
 }
 
-export { APIError, AuthenticationError, BadRequestError, type BaseChunk, ChecksumError, type Chunk, ConflictError, type CreateJobParams, type DocType, type Document, type DocumentChunk, type DocumentChunkGetParams, type DocumentChunkListParams, type DocumentChunkListResponse, type DocumentChunkPagination, type DocumentChunkResponse, type DocumentChunkType, type DocumentListResponse, Documents, type FileIndex, GatewayTimeoutError, type ImageChunk, InternalServerError, InvalidStateError, type Job, type JobError, JobFailedError, type JobResult, type JobStatus, Jobs, Knowhere, KnowhereError, type KnowhereOptions, type LoadOptions, type Manifest, NetworkError, NotFoundError, type ParseParams, type ParseResult, type ParsingModel, type ParsingParams, PaymentRequiredError, PermissionDeniedError, type PollProgress, PollingTimeoutError, RateLimitError, Retrieval, type RetrievalChannel, type RetrievalFilterMode, type RetrievalQueryParams, type RetrievalQueryResponse, type RetrievalReferencedChunk, type RetrievalResult, type RetrievalSectionExclusion, type RetrievalSource, ServiceUnavailableError, type Statistics, type TableChunk, type TextChunk, TimeoutError, type UploadParams, type UploadProgress, VERSION, ValidationError, type WaitOptions, type WebhookConfig, Knowhere as default };
+export { APIError, type AuthTokenProvider, AuthenticationError, BadRequestError, type BaseChunk, ChecksumError, type Chunk, ConflictError, type CreateJobParams, type DocType, type Document, type DocumentChunk, type DocumentChunkGetParams, type DocumentChunkListParams, type DocumentChunkListResponse, type DocumentChunkPagination, type DocumentChunkResponse, type DocumentChunkType, type DocumentListResponse, type DocumentMetadata, Documents, type FileIndex, GatewayTimeoutError, type ImageChunk, InternalServerError, InvalidStateError, type Job, type JobError, JobFailedError, type JobResult, type JobStatus, Jobs, Knowhere, KnowhereError, type KnowhereOptions, Knowledge, type KnowledgeAsyncJobStatusResponse, type KnowledgeAsyncParseParams, type KnowledgeAsyncParseResponse, type KnowledgeCacheJobResultParams, type KnowledgeChunkType, type KnowledgeGrepMatch, type KnowledgeGrepParams, type KnowledgeGrepResponse, type KnowledgeOutline, type KnowledgeParseParams, type KnowledgeReadChunk, type KnowledgeReadParams, type KnowledgeReadResponse, type KnowledgeSearchParams, type KnowledgeSearchReference, type KnowledgeSearchResponse, type KnowledgeSearchResult, type KnowledgeSection, type KnowledgeStartupRecoveryResponse, type LoadOptions, type LocalKnowledgeDocument, type LocalKnowledgeParseResponse, LocalKnowledgeStore, type Manifest, NetworkError, NotFoundError, type ParseParams, type ParseResult, type ParsingModel, type ParsingParams, PaymentRequiredError, PermissionDeniedError, type PollProgress, PollingTimeoutError, RateLimitError, Retrieval, type RetrievalChannel, type RetrievalFilterMode, type RetrievalQueryParams, type RetrievalQueryResponse, type RetrievalReferencedChunk, type RetrievalResult, type RetrievalSectionExclusion, type RetrievalSource, ServiceUnavailableError, type Statistics, type TableChunk, type TextChunk, TimeoutError, type UploadParams, type UploadProgress, VERSION, ValidationError, type WaitOptions, type WebhookConfig, Knowhere as default };