@anvia/core 0.26.0 → 1.0.0-rc.10

package/dist/types-Sue2hb_L.d.ts

@@ -0,0 +1,403 @@
+import { AgentInteractionRequest, AgentContinuation, AgentInteractionResponse } from './agent/interactions/index.js';
+import { b as RetrySetting } from './retry-CjvSlKGW.js';
+import { M as Message, g as CompletionResponse, U as Usage, R as ReasoningContentType, u as ToolCallPart, i as CompletionSource, r as ProviderToolCall, G as UserMessage, C as CompletionFinishReason, l as ContextUsage, f as CompletionRequest, z as ToolResultOutput, y as ToolResultContentPart, _ as ToolInteractionResponsePart, Z as ToolCallArgumentsMode, J as JsonObject, V as CompletionModelCapabilities, w as ToolDefinition } from './types-DgvozfPc.js';
+import { d as GuardrailPolicyInput, a as GuardrailDecisionRecord } from './types-DhkodEft.js';
+import { e as MemoryCompactionInfo, z as MemoryScope } from './types-DKOXVTcq.js';
+import { D as DeepReadonly, M as MaybePromise } from './type-utils-CtHVDRn_.js';
+import { d as ToolCallStreamEvent } from './tool-BpqpoRSE.js';
+import { A as AgentMiddleware } from './middleware-kcF8AusP.js';
+
+type AgentLifecycleRunEvent = {
+    runId: string;
+};
+type AgentStartEvent = AgentLifecycleRunEvent & {
+    input: DeepReadonly<Message>;
+    history: DeepReadonly<Message[]>;
+    maxTurns: number;
+};
+type AgentStepFinishEvent<RawResponse = unknown> = AgentLifecycleRunEvent & {
+    step: number;
+    response: DeepReadonly<CompletionResponse<RawResponse>>;
+    usage: DeepReadonly<Usage>;
+};
+type AgentToolStartEvent = AgentLifecycleRunEvent & {
+    step: number;
+    toolName: string;
+    toolCallId?: string | undefined;
+    input: unknown;
+};
+type AgentToolFinishEventBase = AgentToolStartEvent & {
+    durationMs: number;
+};
+type AgentToolFinishEvent = (AgentToolFinishEventBase & {
+    success: true;
+    output: unknown;
+}) | (AgentToolFinishEventBase & {
+    success: false;
+    error: unknown;
+});
+type AgentFinishEventBase = AgentLifecycleRunEvent & {
+    text: string;
+    usage: DeepReadonly<Usage>;
+    messages: DeepReadonly<Message[]>;
+    memoryCompaction?: DeepReadonly<MemoryCompactionInfo> | undefined;
+};
+type AgentFinishEvent<Output = string> = (AgentFinishEventBase & {
+    status: "completed";
+    output: DeepReadonly<Output>;
+}) | (AgentFinishEventBase & {
+    status: "blocked";
+    stage: "input" | "output";
+}) | (AgentFinishEventBase & {
+    status: "suspended";
+    interaction: DeepReadonly<AgentInteractionRequest>;
+});
+type AgentErrorEvent = AgentLifecycleRunEvent & {
+    error: unknown;
+    usage: DeepReadonly<Usage>;
+    messages: DeepReadonly<Message[]>;
+};
+type AgentLifecycle<Output = string, RawResponse = unknown> = {
+    onStart?(event: AgentStartEvent): MaybePromise<void>;
+    onStepFinish?(event: AgentStepFinishEvent<RawResponse>): MaybePromise<void>;
+    onToolStart?(event: AgentToolStartEvent): MaybePromise<void>;
+    onToolFinish?(event: AgentToolFinishEvent): MaybePromise<void>;
+    onFinish?(event: AgentFinishEvent<Output>): MaybePromise<void>;
+    onError?(event: AgentErrorEvent): MaybePromise<void>;
+};
+
+type AgentPrompt = string | UserMessage;
+type AgentInput = {
+    prompt: AgentPrompt;
+    messages?: never;
+    session?: MemoryScope | undefined;
+    continuation?: never;
+    response?: never;
+} | {
+    messages: readonly Message[];
+    prompt?: never;
+    session?: never;
+    continuation?: never;
+    response?: never;
+} | {
+    continuation: AgentContinuation;
+    response: AgentInteractionResponse;
+    prompt?: never;
+    messages?: never;
+    session?: never;
+};
+type AgentSteerInput = {
+    prompt: AgentPrompt;
+    messages?: never;
+} | {
+    messages: readonly UserMessage[];
+    prompt?: never;
+};
+type AgentRunSettings<Output = string, RawResponse = unknown> = {
+    maxTurns?: number | undefined;
+    retries?: RetrySetting | undefined;
+    abortSignal?: AbortSignal | undefined;
+    lifecycle?: AgentLifecycle<Output, RawResponse> | undefined;
+    guardrails?: GuardrailPolicyInput | undefined;
+    toolConcurrency?: number | undefined;
+    middlewares?: readonly AgentMiddleware[] | undefined;
+    trace?: AgentTraceOptions | undefined;
+};
+type AgentRunOptions<Output = string, RawResponse = unknown> = AgentInput & AgentRunSettings<Output, RawResponse>;
+type AgentRunLink = Readonly<{
+    runId: string;
+    interactionId: string;
+}>;
+type AgentResultBase = {
+    runId: string;
+    text: string;
+    usage: Usage;
+    finishReason?: CompletionFinishReason | undefined;
+    providerFinishReason?: string | undefined;
+    contextUsage?: ContextUsage | undefined;
+    messages: Message[];
+    trace?: AgentTraceInfo | undefined;
+    guardrails?: GuardrailDecisionRecord[] | undefined;
+    sources?: CompletionSource[] | undefined;
+    providerToolCalls?: ProviderToolCall[] | undefined;
+    memoryCompaction?: MemoryCompactionInfo | undefined;
+    resumedFrom?: AgentRunLink | undefined;
+};
+type AgentResponse<Output = string> = AgentResultBase & {
+    status: "completed";
+    output: Output;
+};
+type AgentBlockedResult = AgentResultBase & {
+    status: "blocked";
+    stage: "input" | "output";
+};
+type AgentSuspendedResult = AgentResultBase & {
+    status: "suspended";
+    interaction: AgentInteractionRequest;
+    continuation: AgentContinuation;
+};
+type AgentResult<Output = string> = AgentResponse<Output> | AgentBlockedResult | AgentSuspendedResult;
+type AgentDeltaEvent = {
+    type: "text_delta";
+    delta: string;
+} | {
+    type: "reasoning_delta";
+    delta: string;
+    id?: string;
+    contentType?: ReasoningContentType;
+    signature?: string;
+} | {
+    type: "tool_call";
+    toolCall: ToolCallPart;
+} | {
+    type: "source";
+    source: CompletionSource;
+} | {
+    type: "provider_tool_call";
+    toolCall: ProviderToolCall;
+};
+type AgentErrorStreamEvent = {
+    type: "error";
+    error: unknown;
+    usage: Usage;
+};
+type AgentToolCallDeltaEvent = {
+    type: "tool_call_delta";
+    turn: number;
+    id: string;
+    callId?: string;
+    name?: string;
+    argumentsDelta?: string;
+    argumentsMode?: ToolCallArgumentsMode;
+    signature?: string;
+};
+type AgentMemoryCompactionEvent = MemoryCompactionInfo & {
+    type: "memory_compaction";
+};
+type AgentInteractionResponseEvent = {
+    type: "interaction_response";
+    response: ToolInteractionResponsePart;
+    sourceRunId: string;
+};
+type AgentSteerReceipt = Readonly<{
+    id: string;
+    status: "queued";
+}>;
+type AgentSteeringAppliedEvent = {
+    type: "steering_applied";
+    id: string;
+    turn: number;
+};
+type AgentChildStreamEventBase<Output = string, RawResponse = unknown> = {
+    type: "turn_start";
+    turn: number;
+    prompt: Message;
+    history: Message[];
+} | {
+    type: "generation_start";
+    turn: number;
+    request: CompletionRequest;
+    modelInfo: AgentGenerationModelInfo;
+} | {
+    type: "text_delta";
+    turn: number;
+    delta: string;
+} | {
+    type: "reasoning_delta";
+    turn: number;
+    delta: string;
+    id?: string;
+    contentType?: ReasoningContentType;
+    signature?: string;
+} | {
+    type: "tool_call";
+    turn: number;
+    toolCall: ToolCallPart;
+} | {
+    type: "source";
+    turn: number;
+    source: CompletionSource;
+} | {
+    type: "provider_tool_call";
+    turn: number;
+    toolCall: ProviderToolCall;
+} | {
+    type: "tool_result";
+    turn: number;
+    toolName: string;
+    toolCallId: string;
+    callId?: string;
+    internalCallId: string;
+    args: string;
+    output: ToolResultOutput;
+    result: string;
+    structuredResult?: readonly ToolResultContentPart[] | undefined;
+} | {
+    type: "turn_end";
+    turn: number;
+    response: CompletionResponse<RawResponse>;
+    firstDeltaMs?: number | undefined;
+} | {
+    type: "guardrail_decision";
+    turn?: number | undefined;
+    decision: GuardrailDecisionRecord;
+} | AgentMemoryCompactionEvent | AgentInteractionResponseEvent | AgentSteeringAppliedEvent | {
+    type: "final";
+    result: AgentResult<Output>;
+} | AgentErrorStreamEvent;
+type AgentChildStreamEvent<Output = string, RawResponse = unknown> = AgentChildStreamEventBase<Output, RawResponse> | AgentToolCallDeltaEvent;
+type AgentToolStreamEvent = {
+    type: "agent_tool_event";
+    turn: number;
+    toolName: string;
+    toolCallId?: string;
+    internalCallId: string;
+    agentId: string;
+    agentName?: string;
+    event: AgentChildStreamEvent<unknown, unknown>;
+};
+type AgentStreamEvent<Output = string, RawResponse = unknown> = AgentChildStreamEvent<Output, RawResponse> | AgentToolStreamEvent;
+interface AgentStream<Event = AgentStreamEvent> extends AsyncIterable<Event> {
+    steer(input: AgentSteerInput): AgentSteerReceipt;
+}
+
+type AgentTraceInfo = {
+    readonly observer: string;
+    readonly traceId?: string | undefined;
+    readonly observationId?: string | undefined;
+};
+type AgentObserverTraceInfo = Omit<AgentTraceInfo, "observer">;
+type AgentTraceOptions = {
+    readonly name?: string | undefined;
+    readonly userId?: string | undefined;
+    readonly sessionId?: string | undefined;
+    readonly metadata?: DeepReadonly<JsonObject> | undefined;
+    readonly tags?: readonly string[] | undefined;
+    readonly version?: string | undefined;
+    readonly traceId?: string | undefined;
+    readonly promptRef?: AgentRunPromptRef | undefined;
+};
+type AgentRunPromptRef = {
+    readonly name: string;
+    readonly version?: number | undefined;
+};
+type AgentRunStartArgs = {
+    readonly runId: string;
+    readonly agentName?: string | undefined;
+    readonly agentDescription?: string | undefined;
+    readonly instructions?: string | undefined;
+    readonly trace?: DeepReadonly<AgentTraceOptions> | undefined;
+    readonly prompt: DeepReadonly<Message>;
+    readonly promptRef?: DeepReadonly<AgentRunPromptRef> | undefined;
+    readonly history: readonly DeepReadonly<Message>[];
+    readonly maxTurns: number;
+};
+type AgentRunEndArgsBase = {
+    readonly runId: string;
+    readonly text: string;
+    readonly usage: DeepReadonly<Usage>;
+    readonly messages: readonly DeepReadonly<Message>[];
+    readonly sources?: readonly DeepReadonly<CompletionSource>[] | undefined;
+    readonly providerToolCalls?: readonly DeepReadonly<ProviderToolCall>[] | undefined;
+    readonly resumedFrom?: DeepReadonly<AgentRunLink> | undefined;
+};
+type AgentRunEndArgs = (AgentRunEndArgsBase & {
+    readonly status: "completed";
+    readonly output: unknown;
+}) | (AgentRunEndArgsBase & {
+    readonly status: "blocked";
+    readonly stage: "input" | "output";
+}) | (AgentRunEndArgsBase & {
+    readonly status: "suspended";
+    readonly interaction: DeepReadonly<AgentInteractionRequest>;
+});
+type AgentRunErrorArgs = {
+    readonly error: unknown;
+    readonly usage: DeepReadonly<Usage>;
+    readonly messages: readonly DeepReadonly<Message>[];
+};
+type AgentGenerationModelInfo = {
+    readonly provider: string;
+    readonly modelId: string;
+    readonly capabilities?: DeepReadonly<CompletionModelCapabilities> | undefined;
+};
+type AgentGenerationStartArgs = {
+    readonly turn: number;
+    readonly request: DeepReadonly<CompletionRequest>;
+    readonly providerRequest?: DeepReadonly<JsonObject> | undefined;
+    readonly modelInfo?: DeepReadonly<AgentGenerationModelInfo> | undefined;
+};
+type AgentGenerationEndArgs<RawResponse = unknown> = {
+    readonly turn: number;
+    readonly response: DeepReadonly<CompletionResponse<RawResponse>>;
+    readonly firstDeltaMs?: number | undefined;
+};
+type AgentGenerationErrorArgs = {
+    readonly turn: number;
+    readonly error: unknown;
+};
+type AgentGenerationUpdateArgs = {
+    readonly turn: number;
+    readonly delta: DeepReadonly<AgentDeltaEvent>;
+};
+type AgentRunEventArgs = {
+    readonly name: string;
+    readonly attributes?: DeepReadonly<JsonObject> | undefined;
+    readonly level?: "DEFAULT" | "WARNING" | "ERROR" | undefined;
+    readonly timestamp?: string | undefined;
+};
+type AgentToolStartArgs = {
+    readonly turn: number;
+    readonly toolCall: DeepReadonly<ToolCallPart>;
+    readonly toolName: string;
+    readonly args: string;
+    readonly internalCallId: string;
+    readonly toolCallId?: string | undefined;
+    readonly toolDefinition?: DeepReadonly<ToolDefinition> | undefined;
+    readonly toolMetadata?: DeepReadonly<JsonObject> | undefined;
+};
+type AgentToolEndArgs = AgentToolStartArgs & {
+    readonly result: string;
+    readonly structuredResult?: readonly DeepReadonly<ToolResultContentPart>[] | undefined;
+    readonly skipped: boolean;
+};
+type AgentToolErrorArgs = AgentToolStartArgs & {
+    readonly error: unknown;
+};
+type AgentToolSuspendedArgs = AgentToolStartArgs & {
+    readonly interaction: DeepReadonly<AgentInteractionRequest>;
+};
+type AgentToolStreamEventArgs = AgentToolStartArgs & {
+    readonly event: DeepReadonly<ToolCallStreamEvent>;
+};
+interface AgentGenerationObserver {
+    end(args: AgentGenerationEndArgs): void | Promise<void>;
+    error?(args: AgentGenerationErrorArgs): void | Promise<void>;
+    update?(args: AgentGenerationUpdateArgs): void | Promise<void>;
+}
+interface AgentToolObserver {
+    streamEvent?(args: AgentToolStreamEventArgs): void | Promise<void>;
+    end(args: AgentToolEndArgs): void | Promise<void>;
+    suspend?(args: AgentToolSuspendedArgs): void | Promise<void>;
+    error?(args: AgentToolErrorArgs): void | Promise<void>;
+}
+interface AgentRunObserver {
+    readonly trace?: AgentObserverTraceInfo | undefined;
+    startGeneration?(args: AgentGenerationStartArgs): AgentGenerationObserver | undefined | Promise<AgentGenerationObserver | undefined>;
+    startTool?(args: AgentToolStartArgs): AgentToolObserver | undefined | Promise<AgentToolObserver | undefined>;
+    end(args: AgentRunEndArgs): void | Promise<void>;
+    error?(args: AgentRunErrorArgs): void | Promise<void>;
+    event?(args: AgentRunEventArgs): void | Promise<void>;
+}
+interface AgentObserver {
+    startRun(args: AgentRunStartArgs): AgentRunObserver | undefined | Promise<AgentRunObserver | undefined>;
+}
+type AgentObserverMap = Readonly<Record<string, AgentObserver>>;
+type AgentObserverErrorPolicy = "ignore" | "throw";
+type AgentObservabilityOptions<Observers extends AgentObserverMap = AgentObserverMap> = {
+    readonly observers: Observers;
+    readonly primaryTrace?: Extract<keyof Observers, string> | undefined;
+    readonly errorPolicy?: AgentObserverErrorPolicy | undefined;
+};
+
+export type { AgentBlockedResult as A, AgentGenerationObserver as B, AgentGenerationStartArgs as C, AgentGenerationUpdateArgs as D, AgentObservabilityOptions as E, AgentObserver as F, AgentObserverErrorPolicy as G, AgentObserverMap as H, AgentObserverTraceInfo as I, AgentRunEndArgs as J, AgentRunErrorArgs as K, AgentRunEventArgs as L, AgentRunObserver as M, AgentRunPromptRef as N, AgentRunStartArgs as O, AgentToolEndArgs as P, AgentToolErrorArgs as Q, AgentToolObserver as R, AgentToolStartArgs as S, AgentToolStreamEventArgs as T, AgentToolSuspendedArgs as U, AgentTraceInfo as V, AgentTraceOptions as W, AgentChildStreamEvent as a, AgentDeltaEvent as b, AgentErrorEvent as c, AgentErrorStreamEvent as d, AgentFinishEvent as e, AgentInput as f, AgentLifecycle as g, AgentMemoryCompactionEvent as h, AgentPrompt as i, AgentResponse as j, AgentResult as k, AgentRunOptions as l, AgentRunSettings as m, AgentStartEvent as n, AgentSteerInput as o, AgentSteerReceipt as p, AgentStepFinishEvent as q, AgentStream as r, AgentStreamEvent as s, AgentSuspendedResult as t, AgentToolCallDeltaEvent as u, AgentToolFinishEvent as v, AgentToolStartEvent as w, AgentGenerationEndArgs as x, AgentGenerationErrorArgs as y, AgentGenerationModelInfo as z };

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 { V as VectorMetadata, b as VectorMetadataValue, a as EmbeddedDocument } from '../types-Cr4uiYo5.js';
+import { T as Tool } from '../tool-BpqpoRSE.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-CXNE592e.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-CXNE592e.js';
+import '../model-call-options-CZkSw_xN.js';
+import '../retry-CjvSlKGW.js';
+import '../types-DgvozfPc.js';
 
 declare const vectorFilter: {
     eq(key: string, value: VectorMetadataValue): VectorFilter;
@@ -11,48 +13,46 @@ declare const vectorFilter: {
     and(left: VectorFilter, right: VectorFilter): VectorFilter;
     or(left: VectorFilter, right: VectorFilter): VectorFilter;
 };
+declare function matchesVectorFilter(metadata: VectorMetadata | undefined, filter: VectorFilter | undefined): boolean;
+
+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, matchesVectorFilter, retrieveDocuments, vectorFilter };

package/dist/vector-store/index.js

@@ -1,16 +1,20 @@
 import {
-  InMemoryVectorIndex,
   InMemoryVectorStore,
   createVectorSearchTool,
+  matchesVectorFilter,
+  retrieveDocuments,
   vectorFilter
-} from "../chunk-MELYDKWQ.js";
-import "../chunk-MNWK2USR.js";
-import "../chunk-OIMLU4SF.js";
-import "../chunk-WQKHFADH.js";
+} from "../chunk-EMZKPRE6.js";
+import "../chunk-ZA564323.js";
+import "../chunk-3RM57ZT2.js";
+import "../chunk-QGX73TSQ.js";
+import "../chunk-3XQGVDU5.js";
+import "../chunk-3RWESPUG.js";
 export {
-  InMemoryVectorIndex,
   InMemoryVectorStore,
   createVectorSearchTool,
+  matchesVectorFilter,
+  retrieveDocuments,
   vectorFilter
 };
 //# sourceMappingURL=index.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@anvia/core",
-  "version": "0.26.0",
+  "version": "1.0.0-rc.10",
   "description": "Core runtime primitives for context-aware Anvia agents.",
   "author": "anvia",
   "maintainer": "Indra Zulfi",
@@ -17,6 +17,7 @@
     "access": "public"
   },
   "type": "module",
+  "sideEffects": false,
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "exports": {
@@ -28,13 +29,17 @@
       "types": "./dist/agent/index.d.ts",
       "import": "./dist/agent/index.js"
     },
+    "./agent/interactions": {
+      "types": "./dist/agent/interactions/index.d.ts",
+      "import": "./dist/agent/interactions/index.js"
+    },
     "./internal/agent": {
       "types": "./dist/internal/agent.d.ts",
       "import": "./dist/internal/agent.js"
     },
-    "./audio-generation": {
-      "types": "./dist/audio-generation/index.d.ts",
-      "import": "./dist/audio-generation/index.js"
+    "./speech-generation": {
+      "types": "./dist/speech-generation/index.d.ts",
+      "import": "./dist/speech-generation/index.js"
     },
     "./completion": {
       "types": "./dist/completion/index.d.ts",
@@ -48,9 +53,9 @@
       "types": "./dist/evals/index.d.ts",
       "import": "./dist/evals/index.js"
     },
-    "./loaders": {
-      "types": "./dist/loaders/index.d.ts",
-      "import": "./dist/loaders/index.js"
+    "./documents": {
+      "types": "./dist/documents/index.d.ts",
+      "import": "./dist/documents/index.js"
     },
     "./extractor": {
       "types": "./dist/extractor/index.d.ts",
@@ -68,10 +73,6 @@
       "types": "./dist/memory/index.d.ts",
       "import": "./dist/memory/index.js"
     },
-    "./hooks": {
-      "types": "./dist/hooks/index.d.ts",
-      "import": "./dist/hooks/index.js"
-    },
     "./model-listing": {
       "types": "./dist/model-listing/index.d.ts",
       "import": "./dist/model-listing/index.js"
@@ -84,10 +85,6 @@
       "types": "./dist/pipeline/index.d.ts",
       "import": "./dist/pipeline/index.js"
     },
-    "./request": {
-      "types": "./dist/request/index.d.ts",
-      "import": "./dist/request/index.js"
-    },
     "./skills": {
       "types": "./dist/skills/index.d.ts",
       "import": "./dist/skills/index.js"
@@ -104,10 +101,6 @@
       "types": "./dist/tool/index.d.ts",
       "import": "./dist/tool/index.js"
     },
-    "./ui": {
-      "types": "./dist/ui/index.d.ts",
-      "import": "./dist/ui/index.js"
-    },
     "./transcription": {
       "types": "./dist/transcription/index.d.ts",
       "import": "./dist/transcription/index.js"
@@ -118,21 +111,26 @@
     }
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.30.0",
-    "pdfjs-dist": "^6.2.108",
-    "tinyglobby": "^0.2.17",
-    "undici": "^6.25.0",
     "yaml": "^2.9.0",
     "zod": "^4.4.3"
   },
   "devDependencies": {
     "@types/node": "^24.9.1",
+    "pdfjs-dist": "^6.2.108",
     "tsup": "^8.5.0",
     "typescript": "^5.9.3",
     "vitest": "^4.0.8"
   },
+  "peerDependencies": {
+    "pdfjs-dist": "^6.2.108"
+  },
+  "peerDependenciesMeta": {
+    "pdfjs-dist": {
+      "optional": true
+    }
+  },
   "scripts": {
-    "build": "tsup src/index.ts src/agent/index.ts src/hooks/index.ts src/request/index.ts src/internal/agent.ts src/audio-generation/index.ts src/completion/index.ts src/embeddings/index.ts src/evals/index.ts src/image-generation/index.ts src/loaders/index.ts src/extractor/index.ts src/guardrails/index.ts src/mcp/index.ts src/memory/index.ts src/model-listing/index.ts src/observability/index.ts src/pipeline/index.ts src/skills/index.ts src/streaming/index.ts src/tool/index.ts src/ui/index.ts src/transcription/index.ts src/vector-store/index.ts --format esm --dts --sourcemap --clean",
+    "build": "tsup src/index.ts src/agent/index.ts src/agent/interactions/index.ts src/internal/agent.ts src/speech-generation/index.ts src/completion/index.ts src/embeddings/index.ts src/evals/index.ts src/image-generation/index.ts src/documents/index.ts src/extractor/index.ts src/guardrails/index.ts src/mcp/index.ts src/memory/index.ts src/model-listing/index.ts src/observability/index.ts src/pipeline/index.ts src/skills/index.ts src/streaming/index.ts src/tool/index.ts src/transcription/index.ts src/vector-store/index.ts --format esm --dts --sourcemap --clean",
     "test": "vitest run",
     "typecheck": "tsc --noEmit"
   }