@anvia/core 1.0.0-rc.1 → 1.0.0-rc.3

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-D9rKQ_as.d.ts

@@ -0,0 +1,341 @@
+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 ToolApprovalResponsePart = Readonly<{
+    type: "tool-approval-response";
+    interactionId: string;
+    toolCallId: string;
+    callId?: string;
+    toolName: string;
+    approved: boolean;
+    reason?: string;
+}>;
+type ToolQuestionAnswer = Readonly<{
+    questionId: string;
+    value: string;
+}>;
+type ToolQuestionResponsePart = Readonly<{
+    type: "tool-question-response";
+    interactionId: string;
+    toolCallId: string;
+    callId?: string;
+    toolName: string;
+    answers: readonly ToolQuestionAnswer[];
+}>;
+type ToolInteractionResponsePart = ToolApprovalResponsePart | ToolQuestionResponsePart;
+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 | ToolInteractionResponsePart)[];
+    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 { type ToolQuestionResponsePart 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 ToolApprovalResponsePart as X, type ToolCallArgumentsMode as Y, type ToolInteractionResponsePart as Z, type ToolQuestionAnswer as _, type AssistantGenerationMetadata as a, type UsageDetails as a0, assertCompletionRequestSupported as a1, reasoningDisplayText as a2, textFromAssistantContent as a3, 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-DbolvLtZ.d.ts

@@ -0,0 +1,155 @@
+import { U as Usage, J as JsonObject, M as Message, S as SystemMessage, C as CompletionModel } from './types-D9rKQ_as.js';
+import { b as RetrySetting } from './retry-CjvSlKGW.js';
+
+type MemorySavePolicy = "message" | "turn" | "run";
+type MemoryScope = {
+    sessionId: string;
+    userId?: string | undefined;
+    metadata?: JsonObject | undefined;
+};
+type MemoryScopeKeyOptions = {
+    includeUserId?: boolean | undefined;
+    metadataKeys?: readonly string[] | undefined;
+};
+type CreateMemoryScopeKeyOptions = MemoryScopeKeyOptions & {
+    scope: MemoryScope;
+};
+type MemoryScopeKeyResolver = MemoryScopeKeyOptions | ((options: {
+    scope: MemoryScope;
+}) => string);
+type MemoryLoadOptions = {
+    scope: MemoryScope;
+};
+type MemoryAppendOptions = {
+    scope: MemoryScope;
+    runId: string;
+    turn: number;
+    messages: Message[];
+};
+type MemoryClearOptions = {
+    scope: MemoryScope;
+};
+type MemoryErrorOptions = {
+    scope: MemoryScope;
+    runId: string;
+    error: unknown;
+    messages: Message[];
+};
+type MemoryConversationListOptions = {
+    limit: number;
+    userId?: string | undefined;
+};
+type MemoryConversationGetOptions = {
+    ref: string;
+};
+type MemoryConversationSummary = {
+    /** Opaque, store-specific reference used to retrieve this exact conversation. */
+    ref: string;
+    sessionId: string;
+    userId?: string | undefined;
+    metadata?: JsonObject | undefined;
+    createdAt: string;
+    updatedAt: string;
+    messageCount: number;
+};
+type MemoryConversationMessage = {
+    position: number;
+    runId: string;
+    turn: number;
+    createdAt: string;
+    message: Message;
+};
+type MemoryConversation = MemoryConversationSummary & {
+    messages: MemoryConversationMessage[];
+};
+/** Optional, read-only discovery surface for developer tooling such as Studio. */
+interface MemoryInspector {
+    listConversations(options: MemoryConversationListOptions): Promise<MemoryConversationSummary[]>;
+    getConversation(options: MemoryConversationGetOptions): Promise<MemoryConversation | undefined>;
+}
+interface MemoryStore {
+    readonly inspector?: MemoryInspector | undefined;
+    readonly compaction?: MemoryCompactionCapability | undefined;
+    load(options: MemoryLoadOptions): Promise<Message[]>;
+    append(options: MemoryAppendOptions): Promise<void>;
+    clear(options: MemoryClearOptions): Promise<void>;
+    recordError?(options: MemoryErrorOptions): Promise<void>;
+}
+type MemoryCompactionMetadata = {
+    version: 1;
+    compactedMessageCount: number;
+};
+type MemoryCompactionMessage = Omit<SystemMessage, "metadata"> & {
+    metadata: {
+        anvia: {
+            memoryCompaction: MemoryCompactionMetadata;
+        };
+    };
+};
+type MemoryCompactionSnapshot = {
+    /** Opaque store revision used to reject stale compaction replacements. */
+    revision: string;
+    messages: Message[];
+};
+type MemoryCompactionSnapshotOptions = {
+    scope: MemoryScope;
+};
+type MemoryCompactionReplacePrefixOptions = {
+    scope: MemoryScope;
+    revision: string;
+    messageCount: number;
+    replacement: MemoryCompactionMessage;
+    runId: string;
+};
+type MemoryCompactionReplacePrefixResult = {
+    status: "committed" | "conflict";
+};
+/** Optional atomic prefix-replacement capability used by automatic memory compaction. */
+interface MemoryCompactionCapability {
+    snapshot(options: MemoryCompactionSnapshotOptions): Promise<MemoryCompactionSnapshot>;
+    replacePrefix(options: MemoryCompactionReplacePrefixOptions): Promise<MemoryCompactionReplacePrefixResult>;
+}
+type MemoryCompactorInput = {
+    scope: MemoryScope;
+    messages: Message[];
+    abortSignal?: AbortSignal | undefined;
+};
+type MemoryCompactorResult = {
+    summary: string;
+    usage?: Usage | undefined;
+};
+type MemoryCompactor = (input: MemoryCompactorInput) => Promise<MemoryCompactorResult>;
+type CreateSummaryMemoryCompactorOptions = {
+    model: CompletionModel;
+    instructions?: string | undefined;
+    maxTokens?: number | undefined;
+    temperature?: number | undefined;
+    providerOptions?: JsonObject | undefined;
+    retries?: RetrySetting | undefined;
+};
+type MemoryCompactionConflictRetryOptions = {
+    maxAttempts: number;
+};
+type MemoryCompactionOptions = {
+    trigger: {
+        afterMessages: number;
+    };
+    retention?: {
+        recentUserTurns?: number | undefined;
+    };
+    compactor: MemoryCompactor;
+    conflictRetries?: false | MemoryCompactionConflictRetryOptions | undefined;
+};
+type MemoryOptions = {
+    savePolicy?: MemorySavePolicy | undefined;
+    compaction?: MemoryCompactionOptions | undefined;
+};
+type MemoryCompactionInfo = {
+    originalMessageCount: number;
+    compactedMessageCount: number;
+    retainedMessageCount: number;
+    attempts: number;
+    usage: Usage;
+};
+
+export type { MemoryScopeKeyOptions as A, MemoryScopeKeyResolver as B, CreateMemoryScopeKeyOptions as C, MemoryStore as D, MemoryAppendOptions as M, CreateSummaryMemoryCompactorOptions as a, MemoryClearOptions as b, MemoryCompactionCapability as c, MemoryCompactionConflictRetryOptions as d, MemoryCompactionInfo as e, MemoryCompactionMessage as f, MemoryCompactionMetadata as g, MemoryCompactionOptions as h, MemoryCompactionReplacePrefixOptions as i, MemoryCompactionReplacePrefixResult as j, MemoryCompactionSnapshot as k, MemoryCompactionSnapshotOptions as l, MemoryCompactor as m, MemoryCompactorInput as n, MemoryCompactorResult as o, MemoryConversation as p, MemoryConversationGetOptions as q, MemoryConversationListOptions as r, MemoryConversationMessage as s, MemoryConversationSummary as t, MemoryErrorOptions as u, MemoryInspector as v, MemoryLoadOptions as w, MemoryOptions as x, MemorySavePolicy as y, MemoryScope as z };

package/dist/{types-DhQfwiZn.d.ts → types-RT3cuyRk.d.ts}

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

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

@@ -1,8 +1,10 @@
-import { b as VectorMetadataValue, V as VectorMetadata, E as EmbeddingModel, a as EmbeddedDocument, f as Embedding } from '../types-p55Jc-sr.js';
-import { T as Tool } from '../tool-C_8GudXn.js';
-import { a as VectorFilter, V as VectorSearchIndex, I as IndexStrategy, b as VectorSearchRequest, c as VectorSearchResult, d as VectorInspectRequest, e as VectorInspectPage, f as VectorSearchToolOptions } from '../types-DT3nEemY.js';
-export { L as LshOptions, g as VectorInspectItem } from '../types-DT3nEemY.js';
-import '../types-B3A4YxaA.js';
+import { b as VectorMetadataValue, V as VectorMetadata, a as EmbeddedDocument } from '../types-Cr4uiYo5.js';
+import { T as Tool } from '../tool-r62gf3QY.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-C3gv9EX6.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-C3gv9EX6.js';
+import '../model-call-options-CZkSw_xN.js';
+import '../retry-CjvSlKGW.js';
+import '../types-D9rKQ_as.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 };