@anvia/core 0.26.0 → 1.0.0-rc.2

package/dist/types-CQ_ioXWK.d.ts

@@ -0,0 +1,319 @@
+import { M as ModelCallOptions } from './model-call-options-CZkSw_xN.js';
+
+type JsonPrimitive = string | number | boolean | null;
+type JsonValue = JsonPrimitive | JsonObject | JsonValue[];
+type JsonObject = {
+    [key: string]: JsonValue | undefined;
+};
+type Document = {
+    id: string;
+    text: string;
+    additionalProps?: Record<string, string>;
+};
+type TextPart = Readonly<{
+    type: "text";
+    text: string;
+    signature?: string;
+}>;
+type ImageDetail = "auto" | "low" | "high";
+type FileData = Readonly<{
+    type: "url";
+    url: string;
+}> | Readonly<{
+    type: "data";
+    data: string;
+}> | Readonly<{
+    type: "text";
+    text: string;
+}>;
+type ImagePart = Readonly<{
+    type: "image";
+    image: Exclude<FileData, Readonly<{
+        type: "text";
+        text: string;
+    }>>;
+    mediaType?: string;
+    detail?: ImageDetail;
+}>;
+type FilePart = Readonly<{
+    type: "file";
+    data: FileData;
+    mediaType: string;
+    filename?: string;
+}>;
+type ReasoningPart = Readonly<{
+    type: "reasoning";
+    text: string;
+    id?: string;
+    details?: readonly ReasoningDetail[];
+}>;
+type ReasoningDetail = Readonly<{
+    type: "text";
+    text: string;
+    signature?: string;
+}> | Readonly<{
+    type: "summary";
+    text: string;
+}> | Readonly<{
+    type: "encrypted";
+    data: string;
+}> | Readonly<{
+    type: "redacted";
+    data: string;
+}>;
+type ReasoningContentType = ReasoningDetail["type"];
+type ToolCallPart = Readonly<{
+    type: "tool-call";
+    toolCallId: string;
+    callId?: string;
+    toolName: string;
+    input: JsonValue;
+    signature?: string;
+}>;
+type ToolResultContentPart = TextPart | FilePart;
+type ToolResultOutput = Readonly<{
+    type: "text";
+    value: string;
+}> | Readonly<{
+    type: "json";
+    value: JsonValue;
+}> | Readonly<{
+    type: "content";
+    value: readonly ToolResultContentPart[];
+}> | Readonly<{
+    type: "execution-denied";
+    reason?: string;
+}> | Readonly<{
+    type: "error-text";
+    value: string;
+}> | Readonly<{
+    type: "error-json";
+    value: JsonValue;
+}>;
+type ToolResultPart = Readonly<{
+    type: "tool-result";
+    toolCallId: string;
+    callId?: string;
+    toolName: string;
+    output: ToolResultOutput;
+}>;
+type UserContentPart = TextPart | ImagePart | FilePart;
+type AssistantContentPart = TextPart | ImagePart | FilePart | ReasoningPart | ToolCallPart;
+type SystemMessage<Metadata extends JsonObject = JsonObject> = Readonly<{
+    role: "system";
+    content: string;
+    metadata?: Metadata;
+}>;
+type UserMessage<Metadata extends JsonObject = JsonObject> = Readonly<{
+    role: "user";
+    content: string | readonly UserContentPart[];
+    metadata?: Metadata;
+}>;
+type AssistantMessage<Metadata extends JsonObject = JsonObject> = Readonly<{
+    role: "assistant";
+    id?: string;
+    content: string | readonly AssistantContentPart[];
+    metadata?: Metadata;
+}>;
+type ToolMessage<Metadata extends JsonObject = JsonObject> = Readonly<{
+    role: "tool";
+    content: readonly ToolResultPart[];
+    metadata?: Metadata;
+}>;
+type Message<Metadata extends JsonObject = JsonObject> = SystemMessage<Metadata> | UserMessage<Metadata> | AssistantMessage<Metadata> | ToolMessage<Metadata>;
+declare function reasoningDisplayText(reasoning: ReasoningPart | readonly ReasoningDetail[]): string;
+type ToolChoice = "auto" | "required" | "none" | {
+    type: "function";
+    name: string;
+};
+type ToolDefinition = {
+    name: string;
+    description: string;
+    parameters: JsonObject;
+};
+/**
+ * A tool executed by the model provider rather than by Anvia's local tool runtime.
+ *
+ * Provider packages expose typed factories for these values. Application code can
+ * pass them through the same high-level `tools` APIs used for local tools.
+ */
+type ProviderTool = {
+    kind: "provider";
+    provider: string;
+    name: string;
+    configuration?: JsonObject;
+};
+type CompletionTool = ToolDefinition | ProviderTool;
+declare function isProviderTool(value: unknown): value is ProviderTool;
+type CompletionSource = {
+    type: "url";
+    url: string;
+    title?: string;
+    id?: string;
+    startIndex?: number;
+    endIndex?: number;
+};
+type ProviderToolCall = {
+    id: string;
+    name: string;
+    status?: string;
+    details?: JsonObject;
+};
+/**
+ * Provider-normalized, mutually exclusive usage buckets.
+ *
+ * Every token should appear in exactly one non-total bucket. `total` is the
+ * only aggregate key and should equal the sum of the other buckets.
+ */
+type UsageDetails = Record<string, number>;
+type ModelContextLimits = {
+    contextWindow: number;
+    maxInputTokens?: number;
+    maxOutputTokens?: number;
+};
+type CompletionModelInfo = {
+    modelId: string;
+    context: ModelContextLimits;
+};
+type ContextUsage = {
+    model: CompletionModelInfo;
+    usedTokens: number;
+    remainingTokens: number;
+    usedPercent: number;
+    remainingPercent: number;
+};
+declare function calculateContextUsage(usage: Usage, model: CompletionModelInfo | undefined): ContextUsage | undefined;
+declare function withContextUsage<RawResponse>(response: CompletionResponse<RawResponse>, model: CompletionModelInfo | undefined): CompletionResponse<RawResponse>;
+declare function resolveModelContextLimits(modelId: string, catalog: Readonly<Record<string, ModelContextLimits>>, override?: ModelContextLimits): ModelContextLimits | undefined;
+type AssistantGenerationMetadata = {
+    provider: string;
+    modelId: string;
+    usage: Usage;
+    contextUsage?: ContextUsage;
+    sources?: CompletionSource[];
+    providerToolCalls?: ProviderToolCall[];
+};
+type Usage = {
+    inputTokens: number;
+    outputTokens: number;
+    totalTokens: number;
+    cachedInputTokens: number;
+    cacheCreationInputTokens: number;
+    details?: UsageDetails;
+};
+declare const Usage: {
+    empty(): Usage;
+    add(left: Usage, right: Usage): Usage;
+};
+declare function getAssistantGenerationMetadata(message: Message): AssistantGenerationMetadata | undefined;
+type CompletionRequest = {
+    instructions?: string;
+    chatHistory: Message[];
+    documents: Document[];
+    tools: ToolDefinition[];
+    providerTools?: ProviderTool[];
+    temperature?: number;
+    maxTokens?: number;
+    toolChoice?: ToolChoice;
+    providerOptions?: JsonObject;
+    outputSchema?: JsonObject;
+};
+type CompletionResponse<RawResponse = unknown> = {
+    choice: AssistantContentPart[];
+    usage: Usage;
+    contextUsage?: ContextUsage;
+    rawResponse: RawResponse;
+    messageId?: string;
+    sources?: CompletionSource[];
+    providerToolCalls?: ProviderToolCall[];
+};
+type CompletionResult<Output = string, RawResponse = unknown> = {
+    output: Output;
+    text: string;
+    content: readonly AssistantContentPart[];
+    usage: Usage;
+    contextUsage?: ContextUsage;
+    rawResponse: RawResponse;
+    messageId?: string;
+    sources?: readonly CompletionSource[];
+    providerToolCalls?: readonly ProviderToolCall[];
+};
+type CompletionModelCapabilities = {
+    streaming: boolean;
+    tools: boolean;
+    toolChoice: boolean;
+    imageInput: boolean;
+    documentInput: boolean;
+    outputSchema: boolean;
+    reasoning: boolean;
+    providerTools?: boolean;
+};
+interface CompletionModel<RawResponse = unknown> {
+    readonly provider: string;
+    readonly modelId: string;
+    readonly contextLimits?: ModelContextLimits | undefined;
+    readonly capabilities: CompletionModelCapabilities;
+    traceRequest?(request: CompletionRequest, options?: {
+        stream?: boolean | undefined;
+    }): JsonObject | undefined;
+    completion(request: CompletionRequest, options?: ModelCallOptions): Promise<CompletionResponse<RawResponse>>;
+}
+type ToolCallArgumentsMode = "append" | "replace";
+type CompletionStreamPart = {
+    type: "text_delta";
+    delta: string;
+} | {
+    type: "reasoning_delta";
+    delta: string;
+    id?: string;
+    contentType?: ReasoningContentType;
+    signature?: string;
+} | {
+    type: "tool_call_delta";
+    id: string;
+    callId?: string;
+    name?: string;
+    argumentsDelta?: string;
+    argumentsMode?: ToolCallArgumentsMode;
+    signature?: string;
+} | {
+    type: "tool_call";
+    toolCall: ToolCallPart;
+} | {
+    type: "source";
+    source: CompletionSource;
+} | {
+    type: "provider_tool_call";
+    toolCall: ProviderToolCall;
+} | {
+    type: "message_id";
+    id: string;
+};
+type CompletionModelStreamEvent<RawResponse = unknown> = CompletionStreamPart | {
+    type: "final";
+    response: CompletionResponse<RawResponse>;
+} | {
+    type: "error";
+    error: unknown;
+    usage?: Usage;
+};
+type CompletionStreamEvent<Output = string, RawResponse = unknown> = CompletionStreamPart | {
+    type: "final";
+    result: CompletionResult<Output, RawResponse>;
+} | {
+    type: "error";
+    error: unknown;
+    usage: Usage;
+};
+interface StreamingCompletionModel<RawResponse = unknown> extends CompletionModel<RawResponse> {
+    streamCompletion(request: CompletionRequest, options?: ModelCallOptions): AsyncIterable<CompletionModelStreamEvent<RawResponse>>;
+}
+declare class CompletionCapabilityError extends Error {
+    constructor(message: string);
+}
+declare function assertCompletionRequestSupported(model: CompletionModel, request: CompletionRequest, options?: {
+    streaming?: boolean | undefined;
+}): void;
+declare function textFromAssistantContent(content: readonly AssistantContentPart[]): string;
+
+export { textFromAssistantContent as $, type AssistantContentPart as A, type UserContentPart as B, type CompletionModel as C, type Document as D, type UserMessage as E, type FileData as F, calculateContextUsage as G, getAssistantGenerationMetadata as H, type ImageDetail as I, type JsonObject as J, isProviderTool as K, resolveModelContextLimits as L, type Message as M, withContextUsage as N, CompletionCapabilityError as O, type ProviderTool as P, type CompletionModelCapabilities as Q, type ReasoningContentType as R, type SystemMessage as S, type TextPart as T, Usage as U, type CompletionStreamPart as V, type StreamingCompletionModel as W, type ToolCallArgumentsMode as X, type UsageDetails as Y, assertCompletionRequestSupported as Z, reasoningDisplayText as _, type AssistantGenerationMetadata as a, type AssistantMessage as b, type CompletionModelInfo as c, type CompletionModelStreamEvent as d, type CompletionRequest as e, type CompletionResponse as f, type CompletionResult as g, type CompletionSource as h, type CompletionStreamEvent as i, type CompletionTool as j, type ContextUsage as k, type FilePart as l, type ImagePart as m, type JsonPrimitive as n, type JsonValue as o, type ModelContextLimits as p, type ProviderToolCall as q, type ReasoningDetail as r, type ReasoningPart as s, type ToolCallPart as t, type ToolChoice as u, type ToolDefinition as v, type ToolMessage as w, type ToolResultContentPart as x, type ToolResultOutput as y, type ToolResultPart as z };

package/dist/types-Cr4uiYo5.d.ts

@@ -0,0 +1,99 @@
+import { M as ModelCallOptions } from './model-call-options-CZkSw_xN.js';
+import { b as RetrySetting } from './retry-CjvSlKGW.js';
+
+type Embedding = {
+    document: string;
+    vector: number[];
+};
+type SparseVector = {
+    indices: number[];
+    values: number[];
+};
+type SparseEmbedding = {
+    document: string;
+    vector: SparseVector;
+};
+interface EmbeddingModel {
+    readonly provider: string;
+    readonly modelId: string;
+    readonly dimensions?: number | undefined;
+    readonly maxBatchSize?: number | undefined;
+    embedTexts(texts: string[], options?: ModelCallOptions | undefined): Promise<Embedding[]>;
+}
+/** Sparse lexical/neural encoder used for hybrid retrieval channels. */
+interface SparseEmbeddingModel {
+    readonly provider: string;
+    readonly modelId: string;
+    readonly maxBatchSize?: number | undefined;
+    /** Embed passage/document texts for indexing. */
+    embedTexts(texts: string[], options?: ModelCallOptions | undefined): Promise<SparseEmbedding[]>;
+    /** Embed a search query (may differ from passage encoding for models like SPLADE). */
+    embedQuery(query: string, options?: ModelCallOptions | undefined): Promise<SparseEmbedding>;
+}
+type EmbeddedDocument<T, Metadata extends VectorMetadata = VectorMetadata> = {
+    id: string;
+    document: T;
+    metadata?: Metadata | undefined;
+    embeddings: Embedding[];
+    /** Optional sparse vectors aligned 1:1 with `embeddings` by chunk index. */
+    sparseEmbeddings?: SparseEmbedding[] | undefined;
+};
+type VectorMetadataValue = string | number | boolean | null;
+type VectorMetadata = Record<string, VectorMetadataValue>;
+type EmbeddingOperationOptions = {
+    retries?: RetrySetting | undefined;
+    abortSignal?: AbortSignal | undefined;
+};
+type EmbedTextOptions = EmbeddingOperationOptions & {
+    model: EmbeddingModel;
+    text: string;
+};
+type EmbedTextsOptions = EmbeddingOperationOptions & {
+    model: EmbeddingModel;
+    texts: string[];
+    concurrency?: number | undefined;
+};
+type EmbedSparseTextsOptions = EmbeddingOperationOptions & {
+    model: SparseEmbeddingModel;
+    texts: string[];
+    concurrency?: number | undefined;
+};
+type EmbedSparseQueryOptions = EmbeddingOperationOptions & {
+    model: SparseEmbeddingModel;
+    query: string;
+};
+type EmbedDocumentsBaseOptions<T, Metadata extends VectorMetadata = VectorMetadata> = EmbeddingOperationOptions & {
+    documents: T[];
+    id?: ((document: T, index: number) => string) | undefined;
+    content(document: T, index: number): string | string[];
+    metadata?: ((document: T, index: number) => Metadata | undefined) | undefined;
+    concurrency?: number | undefined;
+};
+type EmbedDocumentsOptions<T, Metadata extends VectorMetadata = VectorMetadata> = EmbedDocumentsBaseOptions<T, Metadata> & {
+    model: EmbeddingModel;
+    models?: never;
+};
+type EmbedHybridDocumentsOptions<T, Metadata extends VectorMetadata = VectorMetadata> = EmbedDocumentsBaseOptions<T, Metadata> & {
+    model?: never;
+    models: {
+        dense: EmbeddingModel;
+        sparse: SparseEmbeddingModel;
+    };
+};
+type EmbedTextResult = {
+    embedding: Embedding;
+};
+type EmbedTextsResult = {
+    embeddings: Embedding[];
+};
+type EmbedSparseTextsResult = {
+    embeddings: SparseEmbedding[];
+};
+type EmbedSparseQueryResult = {
+    embedding: SparseEmbedding;
+};
+type EmbedDocumentsResult<T, Metadata extends VectorMetadata = VectorMetadata> = {
+    documents: Array<EmbeddedDocument<T, Metadata>>;
+};
+
+export type { EmbeddingModel as E, SparseVector as S, VectorMetadata as V, EmbeddedDocument as a, VectorMetadataValue as b, SparseEmbeddingModel as c, EmbedDocumentsOptions as d, EmbedDocumentsResult as e, EmbedHybridDocumentsOptions as f, EmbedSparseQueryOptions as g, EmbedSparseQueryResult as h, EmbedSparseTextsOptions as i, EmbedSparseTextsResult as j, EmbedTextOptions as k, EmbedTextResult as l, EmbedTextsOptions as m, EmbedTextsResult as n, EmbedDocumentsBaseOptions as o, Embedding as p, EmbeddingOperationOptions as q, SparseEmbedding as r };

package/dist/{types-04LqWrmy.d.ts → types-DiJqJejp.d.ts}

@@ -1,4 +1,4 @@
-import { A as AnyTool } from './tool-Cohdv5GC.js';
+import { A as AnyTool } from './tool--Mz4v1eL.js';
 
 type Skill = {
     readonly name: string;

package/dist/types-Dld1TpWj.d.ts

@@ -0,0 +1,130 @@
+import { b as RetrySetting } from './retry-CjvSlKGW.js';
+import { J as JsonObject } from './types-CQ_ioXWK.js';
+import { b as VectorMetadataValue, V as VectorMetadata, a as EmbeddedDocument, S as SparseVector, E as EmbeddingModel, c as SparseEmbeddingModel } from './types-Cr4uiYo5.js';
+
+type VectorFilter = {
+    type: "eq";
+    key: string;
+    value: VectorMetadataValue;
+} | {
+    type: "gt";
+    key: string;
+    value: VectorMetadataValue;
+} | {
+    type: "lt";
+    key: string;
+    value: VectorMetadataValue;
+} | {
+    type: "and";
+    filters: [VectorFilter, VectorFilter];
+} | {
+    type: "or";
+    filters: [VectorFilter, VectorFilter];
+};
+type VectorMetric = "cosine" | "euclidean" | "dotProduct";
+type VectorFusion = "rrf" | "dbsf";
+type LshOptions = {
+    type: "lsh";
+    numTables: number;
+    numHyperplanes: number;
+    seed?: number | undefined;
+};
+type IndexStrategy = {
+    type: "bruteForce";
+} | LshOptions;
+type VectorStoreUpsertOptions<T, Metadata extends VectorMetadata = VectorMetadata> = {
+    documents: Array<EmbeddedDocument<T, Metadata>>;
+    providerOptions?: JsonObject | undefined;
+};
+type VectorSearchRequest = {
+    vector: number[];
+    topK: number;
+    minScore?: number | undefined;
+    filter?: VectorFilter | undefined;
+    providerOptions?: JsonObject | undefined;
+    abortSignal?: AbortSignal | undefined;
+};
+type HybridVectorSearchRequest = VectorSearchRequest & {
+    sparseVector: SparseVector;
+    fusion?: VectorFusion | undefined;
+};
+type VectorSearchResult<T = unknown, Metadata extends VectorMetadata = VectorMetadata> = {
+    score: number;
+    id: string;
+    document: T;
+    metadata?: Metadata | undefined;
+};
+type VectorInspectRequest = {
+    limit: number;
+    cursor?: string | undefined;
+    filter?: VectorFilter | undefined;
+    providerOptions?: JsonObject | undefined;
+    abortSignal?: AbortSignal | undefined;
+};
+type VectorInspectItem<T = unknown, Metadata extends VectorMetadata = VectorMetadata> = {
+    id: string;
+    document: T;
+    metadata?: Metadata | undefined;
+};
+type VectorInspectPage<T = unknown, Metadata extends VectorMetadata = VectorMetadata> = {
+    items: Array<VectorInspectItem<T, Metadata>>;
+    nextCursor?: string | undefined;
+    totalCount?: number | undefined;
+};
+interface VectorStore<T = unknown, Metadata extends VectorMetadata = VectorMetadata> {
+    ensure(): Promise<void>;
+    validate(): Promise<void>;
+    upsert(options: VectorStoreUpsertOptions<T, Metadata>): Promise<void>;
+    search(request: VectorSearchRequest): Promise<Array<VectorSearchResult<T, Metadata>>>;
+    inspect?(request: VectorInspectRequest): Promise<VectorInspectPage<T, Metadata>>;
+}
+interface HybridVectorStore<T = unknown, Metadata extends VectorMetadata = VectorMetadata> extends VectorStore<T, Metadata> {
+    searchHybrid(request: HybridVectorSearchRequest): Promise<Array<VectorSearchResult<T, Metadata>>>;
+}
+type RetrieveDocumentsBaseOptions = {
+    query: string;
+    topK: number;
+    minScore?: number | undefined;
+    filter?: VectorFilter | undefined;
+    retries?: RetrySetting | undefined;
+    abortSignal?: AbortSignal | undefined;
+};
+type RetrieveDocumentsOptions<T, Metadata extends VectorMetadata = VectorMetadata> = RetrieveDocumentsBaseOptions & {
+    store: VectorStore<T, Metadata>;
+    model: EmbeddingModel;
+    models?: never;
+};
+type RetrieveHybridDocumentsOptions<T, Metadata extends VectorMetadata = VectorMetadata> = RetrieveDocumentsBaseOptions & {
+    store: HybridVectorStore<T, Metadata>;
+    model?: never;
+    models: {
+        dense: EmbeddingModel;
+        sparse: SparseEmbeddingModel;
+    };
+    fusion?: VectorFusion | undefined;
+};
+type VectorSearchToolBaseOptions = {
+    name: string;
+    description?: string | undefined;
+    topK?: number | undefined;
+    minScore?: number | undefined;
+    filter?: VectorFilter | undefined;
+    retries?: RetrySetting | undefined;
+};
+type DenseVectorSearchToolOptions<T, Metadata extends VectorMetadata = VectorMetadata> = VectorSearchToolBaseOptions & {
+    store: VectorStore<T, Metadata>;
+    model: EmbeddingModel;
+    models?: never;
+};
+type HybridVectorSearchToolOptions<T, Metadata extends VectorMetadata = VectorMetadata> = VectorSearchToolBaseOptions & {
+    store: HybridVectorStore<T, Metadata>;
+    model?: never;
+    models: {
+        dense: EmbeddingModel;
+        sparse: SparseEmbeddingModel;
+    };
+    fusion?: VectorFusion | undefined;
+};
+type VectorSearchToolOptions<T = unknown, Metadata extends VectorMetadata = VectorMetadata> = DenseVectorSearchToolOptions<T, Metadata> | HybridVectorSearchToolOptions<T, Metadata>;
+
+export type { DenseVectorSearchToolOptions as D, HybridVectorStore as H, IndexStrategy as I, LshOptions as L, RetrieveDocumentsOptions as R, VectorFilter as V, VectorSearchResult as a, VectorInspectRequest as b, VectorInspectPage as c, VectorStore as d, VectorFusion as e, RetrieveHybridDocumentsOptions as f, VectorStoreUpsertOptions as g, VectorSearchRequest as h, VectorSearchToolOptions as i, HybridVectorSearchRequest as j, HybridVectorSearchToolOptions as k, RetrieveDocumentsBaseOptions as l, VectorInspectItem as m, VectorMetric as n, VectorSearchToolBaseOptions as o };

package/dist/vector-store/index.d.ts

@@ -1,8 +1,10 @@
-import { a as VectorMetadataValue, V as VectorMetadata, E as EmbeddingModel, c as EmbeddedDocument, f as Embedding } from '../types-BCTRUGex.js';
-import { T as Tool } from '../tool-Cohdv5GC.js';
-import { V as VectorFilter, a as VectorSearchIndex, I as IndexStrategy, b as VectorSearchRequest, c as VectorSearchResult, d as VectorInspectRequest, e as VectorInspectPage, f as VectorSearchToolOptions } from '../types-O-abTIin.js';
-export { L as LshOptions, g as VectorInspectItem } from '../types-O-abTIin.js';
-import '../types-G12i56s2.js';
+import { b as VectorMetadataValue, V as VectorMetadata, a as EmbeddedDocument } from '../types-Cr4uiYo5.js';
+import { T as Tool } from '../tool--Mz4v1eL.js';
+import { V as VectorFilter, R as RetrieveDocumentsOptions, a as VectorSearchResult, f as RetrieveHybridDocumentsOptions, d as VectorStore, I as IndexStrategy, g as VectorStoreUpsertOptions, h as VectorSearchRequest, b as VectorInspectRequest, c as VectorInspectPage, i as VectorSearchToolOptions } from '../types-Dld1TpWj.js';
+export { D as DenseVectorSearchToolOptions, j as HybridVectorSearchRequest, k as HybridVectorSearchToolOptions, H as HybridVectorStore, L as LshOptions, l as RetrieveDocumentsBaseOptions, e as VectorFusion, m as VectorInspectItem, n as VectorMetric, o as VectorSearchToolBaseOptions } from '../types-Dld1TpWj.js';
+import '../model-call-options-CZkSw_xN.js';
+import '../retry-CjvSlKGW.js';
+import '../types-CQ_ioXWK.js';
 
 declare const vectorFilter: {
     eq(key: string, value: VectorMetadataValue): VectorFilter;
@@ -12,47 +14,44 @@ declare const vectorFilter: {
     or(left: VectorFilter, right: VectorFilter): VectorFilter;
 };
 
+declare function retrieveDocuments<T, Metadata extends VectorMetadata = VectorMetadata>(options: RetrieveDocumentsOptions<T, Metadata>): Promise<Array<VectorSearchResult<T, Metadata>>>;
+declare function retrieveDocuments<T, Metadata extends VectorMetadata = VectorMetadata>(options: RetrieveHybridDocumentsOptions<T, Metadata>): Promise<Array<VectorSearchResult<T, Metadata>>>;
+
 type StoredDocument<T, Metadata extends VectorMetadata> = EmbeddedDocument<T, Metadata>;
-declare class InMemoryVectorStore<T, Metadata extends VectorMetadata = VectorMetadata> {
+type InMemoryVectorStoreOptions = {
+    dimensions?: number | undefined;
+    index?: IndexStrategy | undefined;
+};
+type InMemoryVectorStoreFromDocumentsOptions<T, Metadata extends VectorMetadata = VectorMetadata> = InMemoryVectorStoreOptions & {
+    documents: Array<EmbeddedDocument<T, Metadata>>;
+};
+declare class InMemoryVectorStore<T, Metadata extends VectorMetadata = VectorMetadata> implements VectorStore<T, Metadata> {
     private readonly documents;
-    private indexStrategy;
+    private readonly indexStrategy;
     private lshIndex;
     private embeddingDimension;
-    constructor(options?: {
-        index?: IndexStrategy;
-    });
-    static fromDocuments<T, Metadata extends VectorMetadata = VectorMetadata>(documents: Array<EmbeddedDocument<T, Metadata>>, options?: {
-        index?: IndexStrategy;
-    }): InMemoryVectorStore<T, Metadata>;
-    addDocuments(documents: Array<EmbeddedDocument<T, Metadata>>): this;
-    get(id: string): StoredDocument<T, Metadata> | undefined;
+    constructor(options?: InMemoryVectorStoreOptions);
+    static fromDocuments<T, Metadata extends VectorMetadata = VectorMetadata>(options: InMemoryVectorStoreFromDocumentsOptions<T, Metadata>): InMemoryVectorStore<T, Metadata>;
+    ensure(): Promise<void>;
+    validate(): Promise<void>;
+    upsert(options: VectorStoreUpsertOptions<T, Metadata>): Promise<void>;
+    get(options: {
+        id: string;
+    }): StoredDocument<T, Metadata> | undefined;
     values(): Array<StoredDocument<T, Metadata>>;
     len(): number;
     isEmpty(): boolean;
-    index(model: EmbeddingModel): InMemoryVectorIndex<T, Metadata>;
-    candidates(queryEmbedding: Embedding): Array<StoredDocument<T, Metadata>>;
+    search(request: VectorSearchRequest): Promise<Array<VectorSearchResult<T, Metadata>>>;
+    inspect(request: VectorInspectRequest): Promise<VectorInspectPage<T, Metadata>>;
+    private replaceDocuments;
+    private candidates;
     private rebuildLshIndex;
     private validateDocumentDimensions;
     private validateQueryDimension;
 }
-declare class InMemoryVectorIndex<T, Metadata extends VectorMetadata = VectorMetadata> implements VectorSearchIndex<T, Metadata> {
-    private readonly model;
-    private readonly store;
-    constructor(model: EmbeddingModel, store: InMemoryVectorStore<T, Metadata>);
-    search(request: VectorSearchRequest): Promise<Array<VectorSearchResult<T, Metadata>>>;
-    searchIds(request: VectorSearchRequest): Promise<Array<{
-        score: number;
-        id: string;
-    }>>;
-    inspect(request: VectorInspectRequest): Promise<VectorInspectPage<T, Metadata>>;
-    asTool(options: VectorSearchToolOptions): Tool<{
-        query: string;
-        topK?: number;
-    }, unknown>;
-}
-declare function createVectorSearchTool<T, Metadata extends VectorMetadata>(index: VectorSearchIndex<T, Metadata>, options: VectorSearchToolOptions): Tool<{
+declare function createVectorSearchTool<T, Metadata extends VectorMetadata>(options: VectorSearchToolOptions<T, Metadata>): Tool<{
     query: string;
     topK?: number;
 }, Array<VectorSearchResult<T, Metadata>>>;
 
-export { InMemoryVectorIndex, InMemoryVectorStore, IndexStrategy, VectorFilter, VectorInspectPage, VectorInspectRequest, VectorSearchIndex, VectorSearchRequest, VectorSearchResult, VectorSearchToolOptions, createVectorSearchTool, vectorFilter };
+export { InMemoryVectorStore, type InMemoryVectorStoreFromDocumentsOptions, type InMemoryVectorStoreOptions, IndexStrategy, RetrieveDocumentsOptions, RetrieveHybridDocumentsOptions, VectorFilter, VectorInspectPage, VectorInspectRequest, VectorSearchRequest, VectorSearchResult, VectorSearchToolOptions, VectorStore, VectorStoreUpsertOptions, createVectorSearchTool, retrieveDocuments, vectorFilter };

package/dist/vector-store/index.js

@@ -1,16 +1,16 @@
 import {
-  InMemoryVectorIndex,
   InMemoryVectorStore,
   createVectorSearchTool,
+  retrieveDocuments,
   vectorFilter
-} from "../chunk-MELYDKWQ.js";
-import "../chunk-MNWK2USR.js";
-import "../chunk-OIMLU4SF.js";
-import "../chunk-WQKHFADH.js";
+} from "../chunk-77AIYARB.js";
+import "../chunk-FMHLROPQ.js";
+import "../chunk-TIZYTPJO.js";
+import "../chunk-FN7HLLAZ.js";
 export {
-  InMemoryVectorIndex,
   InMemoryVectorStore,
   createVectorSearchTool,
+  retrieveDocuments,
   vectorFilter
 };
 //# sourceMappingURL=index.js.map