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

package/dist/{index-DxB74ybJ.d.ts → types-3x3mOLHU.d.ts}

@@ -1,9 +1,10 @@
-import { a as RetryOptions } from './retry-D3Ruy-ba.js';
-import { M as Message, g as CompletionResponse, U as Usage, V as ReasoningContentType, p as ToolCall, h as CompletionSource, o as ProviderToolCall, j as ContextUsage, f as CompletionRequest, u as ToolResultContent, X as ToolCallArgumentsMode, J as JsonObject, K as CompletionModelCapabilities, r as ToolDefinition, l as JsonValue } from './types-B3A4YxaA.js';
+import { b as RetrySetting } from './retry-CjvSlKGW.js';
+import { M as Message, f as CompletionResponse, U as Usage, R as ReasoningContentType, t as ToolCallPart, h as CompletionSource, q as ProviderToolCall, E as UserMessage, k as ContextUsage, e as CompletionRequest, y as ToolResultOutput, x as ToolResultContentPart, X as ToolCallArgumentsMode, J as JsonObject, Q as CompletionModelCapabilities, v as ToolDefinition } from './types-CQ_ioXWK.js';
 import { GuardrailPolicyInput, GuardrailDecisionRecord } from './guardrails/index.js';
-import { A as AgentMiddleware } from './middleware-KynLg_RW.js';
+import { e as MemoryCompactionInfo, z as MemoryScope } from './types-BVzM4RsC.js';
 import { D as DeepReadonly, M as MaybePromise } from './type-utils-CtHVDRn_.js';
-import { d as ToolCallStreamEvent } from './tool-C_8GudXn.js';
+import { d as ToolCallStreamEvent } from './tool--Mz4v1eL.js';
+import { A as AgentMiddleware } from './middleware-C7PdmKF7.js';
 
 type AgentLifecycleRunEvent = {
     runId: string;
@@ -34,39 +35,64 @@ type AgentToolFinishEvent = (AgentToolFinishEventBase & {
     success: false;
     error: unknown;
 });
-type AgentFinishEvent = AgentLifecycleRunEvent & {
-    output: string;
+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";
+});
 type AgentErrorEvent = AgentLifecycleRunEvent & {
     error: unknown;
     usage: DeepReadonly<Usage>;
     messages: DeepReadonly<Message[]>;
 };
-type AgentLifecycle<RawResponse = unknown> = {
+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): MaybePromise<void>;
+    onFinish?(event: AgentFinishEvent<Output>): MaybePromise<void>;
     onError?(event: AgentErrorEvent): MaybePromise<void>;
 };
 
-type AgentInput = string | Message | Message[];
-type AgentRunOptions = {
+type AgentPrompt = string | UserMessage;
+type AgentInput = {
+    prompt: AgentPrompt;
+    messages?: never;
+    session?: MemoryScope | undefined;
+} | {
+    messages: readonly Message[];
+    prompt?: never;
+    session?: never;
+};
+type AgentSteerInput = {
+    prompt: AgentPrompt;
+    messages?: never;
+} | {
+    messages: readonly UserMessage[];
+    prompt?: never;
+};
+type AgentRunSettings<Output = string, RawResponse = unknown> = {
     maxTurns?: number | undefined;
-    retries?: RetryOptions | undefined;
-    lifecycle?: AgentLifecycle | 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 AgentResponse = {
-    status: "completed";
+type AgentRunOptions<Output = string, RawResponse = unknown> = AgentInput & AgentRunSettings<Output, RawResponse>;
+type AgentResultBase = {
     runId: string;
-    output: string;
+    text: string;
     usage: Usage;
     contextUsage?: ContextUsage | undefined;
     messages: Message[];
@@ -74,6 +100,15 @@ type AgentResponse = {
     guardrails?: GuardrailDecisionRecord[] | undefined;
     sources?: CompletionSource[] | undefined;
     providerToolCalls?: ProviderToolCall[] | undefined;
+    memoryCompaction?: MemoryCompactionInfo | undefined;
+};
+type AgentResponse<Output = string> = AgentResultBase & {
+    status: "completed";
+    output: Output;
+};
+type AgentBlockedResult = AgentResultBase & {
+    status: "blocked";
+    stage: "input" | "output";
 };
 type AgentApprovalRequiredResult = {
     status: "approval_required";
@@ -81,8 +116,9 @@ type AgentApprovalRequiredResult = {
     approval: AgentToolApprovalRequest;
     usage: Usage;
     messages: Message[];
+    memoryCompaction?: MemoryCompactionInfo | undefined;
 };
-type AgentResult = AgentResponse | AgentApprovalRequiredResult;
+type AgentResult<Output = string> = AgentResponse<Output> | AgentBlockedResult | AgentApprovalRequiredResult;
 type AgentToolApprovalRequest = {
     id: string;
     toolName: string;
@@ -111,7 +147,7 @@ type AgentDeltaEvent = {
     signature?: string;
 } | {
     type: "tool_call";
-    toolCall: ToolCall;
+    toolCall: ToolCallPart;
 } | {
     type: "source";
     source: CompletionSource;
@@ -124,10 +160,6 @@ type AgentErrorStreamEvent = {
     error: unknown;
     usage: Usage;
 };
-type AgentStreamOptions = AgentRunOptions & {
-    /** @default true */
-    includeToolCallDeltas?: boolean;
-};
 type AgentToolCallDeltaEvent = {
     type: "tool_call_delta";
     turn: number;
@@ -138,7 +170,10 @@ type AgentToolCallDeltaEvent = {
     argumentsMode?: ToolCallArgumentsMode;
     signature?: string;
 };
-type AgentChildStreamEventBase<RawResponse = unknown> = {
+type AgentMemoryCompactionEvent = MemoryCompactionInfo & {
+    type: "memory_compaction";
+};
+type AgentChildStreamEventBase<Output = string, RawResponse = unknown> = {
     type: "turn_start";
     turn: number;
     prompt: Message;
@@ -162,7 +197,7 @@ type AgentChildStreamEventBase<RawResponse = unknown> = {
 } | {
     type: "tool_call";
     turn: number;
-    toolCall: ToolCall;
+    toolCall: ToolCallPart;
 } | {
     type: "source";
     turn: number;
@@ -175,11 +210,13 @@ type AgentChildStreamEventBase<RawResponse = unknown> = {
     type: "tool_result";
     turn: number;
     toolName: string;
-    toolCallId?: string;
+    toolCallId: string;
+    callId?: string;
     internalCallId: string;
     args: string;
+    output: ToolResultOutput;
     result: string;
-    structuredResult?: ToolResultContent[] | undefined;
+    structuredResult?: readonly ToolResultContentPart[] | undefined;
 } | {
     type: "turn_end";
     turn: number;
@@ -189,22 +226,12 @@ type AgentChildStreamEventBase<RawResponse = unknown> = {
     type: "guardrail_decision";
     turn?: number | undefined;
     decision: GuardrailDecisionRecord;
-} | {
+} | AgentMemoryCompactionEvent | {
     type: "final";
-    runId: string;
-    output: string;
-    usage: Usage;
-    contextUsage?: ContextUsage | undefined;
-    messages: Message[];
-    trace?: AgentTraceInfo | undefined;
-    guardrails?: GuardrailDecisionRecord[] | undefined;
-    sources?: CompletionSource[] | undefined;
-    providerToolCalls?: ProviderToolCall[] | undefined;
+    result: AgentResponse<Output> | AgentBlockedResult;
 } | AgentApprovalRequiredEvent | AgentErrorStreamEvent;
-type AgentChildStreamEventWithoutToolCallDeltas<RawResponse = unknown> = AgentChildStreamEventBase<RawResponse>;
-type AgentChildStreamEvent<RawResponse = unknown> = AgentChildStreamEventBase<RawResponse> | AgentToolCallDeltaEvent;
-type AgentChildStreamEventWithToolCallDeltas<RawResponse = unknown> = AgentChildStreamEvent<RawResponse>;
-type AgentToolStreamEvent<ChildEvent> = {
+type AgentChildStreamEvent<Output = string, RawResponse = unknown> = AgentChildStreamEventBase<Output, RawResponse> | AgentToolCallDeltaEvent;
+type AgentToolStreamEvent = {
     type: "agent_tool_event";
     turn: number;
     toolName: string;
@@ -212,28 +239,27 @@ type AgentToolStreamEvent<ChildEvent> = {
     internalCallId: string;
     agentId: string;
     agentName?: string;
-    event: ChildEvent;
+    event: AgentChildStreamEvent<unknown, unknown>;
 };
-type AgentStreamEventWithoutToolCallDeltas<RawResponse = unknown> = AgentChildStreamEventWithoutToolCallDeltas<RawResponse> | AgentToolStreamEvent<AgentChildStreamEventWithoutToolCallDeltas<RawResponse>>;
-type AgentStreamEvent<RawResponse = unknown> = AgentChildStreamEvent<RawResponse> | AgentToolStreamEvent<AgentChildStreamEvent<RawResponse>>;
-type AgentStreamEventWithToolCallDeltas<RawResponse = unknown> = AgentStreamEvent<RawResponse>;
+type AgentStreamEvent<Output = string, RawResponse = unknown> = AgentChildStreamEvent<Output, RawResponse> | AgentToolStreamEvent;
 interface AgentStream<Event = AgentStreamEvent> extends AsyncIterable<Event> {
-    steer(input: AgentInput): boolean;
+    steer(input: AgentSteerInput): boolean;
 }
 
 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?: Readonly<Record<string, unknown>> | undefined;
+    readonly metadata?: DeepReadonly<JsonObject> | undefined;
     readonly tags?: readonly string[] | undefined;
     readonly version?: string | undefined;
     readonly traceId?: string | undefined;
-    readonly failOnObserverError?: boolean | undefined;
     readonly promptRef?: AgentRunPromptRef | undefined;
 };
 type AgentRunPromptRef = {
@@ -251,13 +277,20 @@ type AgentRunStartArgs = {
     readonly history: readonly DeepReadonly<Message>[];
     readonly maxTurns: number;
 };
-type AgentRunEndArgs = {
-    readonly output: string;
+type AgentRunEndArgsBase = {
+    readonly text: string;
     readonly usage: DeepReadonly<Usage>;
     readonly messages: readonly DeepReadonly<Message>[];
     readonly sources?: readonly DeepReadonly<CompletionSource>[] | undefined;
     readonly providerToolCalls?: readonly DeepReadonly<ProviderToolCall>[] | undefined;
 };
+type AgentRunEndArgs = (AgentRunEndArgsBase & {
+    readonly status: "completed";
+    readonly output: unknown;
+}) | (AgentRunEndArgsBase & {
+    readonly status: "blocked";
+    readonly stage: "input" | "output";
+});
 type AgentRunErrorArgs = {
     readonly error: unknown;
     readonly usage: DeepReadonly<Usage>;
@@ -265,7 +298,7 @@ type AgentRunErrorArgs = {
 };
 type AgentGenerationModelInfo = {
     readonly provider: string;
-    readonly defaultModel: string;
+    readonly modelId: string;
     readonly capabilities?: DeepReadonly<CompletionModelCapabilities> | undefined;
 };
 type AgentGenerationStartArgs = {
@@ -289,13 +322,13 @@ type AgentGenerationUpdateArgs = {
 };
 type AgentRunEventArgs = {
     readonly name: string;
-    readonly attributes?: Readonly<Record<string, DeepReadonly<JsonValue> | undefined>> | undefined;
+    readonly attributes?: DeepReadonly<JsonObject> | undefined;
     readonly level?: "DEFAULT" | "WARNING" | "ERROR" | undefined;
-    readonly timestamp?: Date | string | undefined;
+    readonly timestamp?: string | undefined;
 };
 type AgentToolStartArgs = {
     readonly turn: number;
-    readonly toolCall: DeepReadonly<ToolCall>;
+    readonly toolCall: DeepReadonly<ToolCallPart>;
     readonly toolName: string;
     readonly args: string;
     readonly internalCallId: string;
@@ -305,7 +338,7 @@ type AgentToolStartArgs = {
 };
 type AgentToolEndArgs = AgentToolStartArgs & {
     readonly result: string;
-    readonly structuredResult?: readonly DeepReadonly<ToolResultContent>[] | undefined;
+    readonly structuredResult?: readonly DeepReadonly<ToolResultContentPart>[] | undefined;
     readonly skipped: boolean;
 };
 type AgentToolErrorArgs = AgentToolStartArgs & {
@@ -325,7 +358,7 @@ interface AgentToolObserver {
     error?(args: AgentToolErrorArgs): void | Promise<void>;
 }
 interface AgentRunObserver {
-    readonly trace?: AgentTraceInfo | undefined;
+    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>;
@@ -334,16 +367,13 @@ interface AgentRunObserver {
 }
 interface AgentObserver {
     startRun(args: AgentRunStartArgs): AgentRunObserver | undefined | Promise<AgentRunObserver | undefined>;
-    flush?(): void | Promise<void>;
-    shutdown?(): void | Promise<void>;
 }
-type AgentObserverRegistration = {
-    readonly observer: AgentObserver;
-    readonly failOnObserverError?: boolean | undefined;
-};
-type ObserveOptions = {
-    readonly failOnObserverError?: boolean | 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;
 };
-declare function createObserver(observer: AgentObserver): AgentObserver;
 
-export { type AgentApprovalDecision as A, type AgentObserverRegistration as B, type AgentGenerationEndArgs as C, type AgentGenerationErrorArgs as D, type AgentGenerationModelInfo as E, type AgentGenerationObserver as F, type AgentGenerationStartArgs as G, type AgentGenerationUpdateArgs as H, type AgentRunEndArgs as I, type AgentRunErrorArgs as J, type AgentRunEventArgs as K, type AgentRunObserver as L, type AgentRunPromptRef as M, type AgentRunStartArgs as N, type ObserveOptions as O, type AgentToolEndArgs as P, type AgentToolErrorArgs as Q, type AgentToolObserver as R, type AgentToolStartArgs as S, type AgentToolStreamEventArgs as T, type AgentTraceInfo as U, type AgentTraceOptions as V, createObserver as W, type AgentApprovalRequiredEvent as a, type AgentApprovalRequiredResult as b, type AgentChildStreamEvent as c, type AgentChildStreamEventWithToolCallDeltas as d, type AgentChildStreamEventWithoutToolCallDeltas as e, type AgentDeltaEvent as f, type AgentErrorEvent as g, type AgentErrorStreamEvent as h, type AgentFinishEvent as i, type AgentInput as j, type AgentLifecycle as k, type AgentResponse as l, type AgentResult as m, type AgentRunOptions as n, type AgentStartEvent as o, type AgentStepFinishEvent as p, type AgentStream as q, type AgentStreamEvent as r, type AgentStreamEventWithToolCallDeltas as s, type AgentStreamEventWithoutToolCallDeltas as t, type AgentStreamOptions as u, type AgentToolApprovalRequest as v, type AgentToolCallDeltaEvent as w, type AgentToolFinishEvent as x, type AgentToolStartEvent as y, type AgentObserver as z };
+export type { AgentApprovalDecision as A, AgentGenerationErrorArgs as B, AgentGenerationModelInfo as C, AgentGenerationObserver as D, AgentGenerationStartArgs as E, AgentGenerationUpdateArgs as F, AgentObservabilityOptions as G, AgentObserver as H, AgentObserverErrorPolicy as I, AgentObserverMap as J, AgentObserverTraceInfo as K, AgentRunEndArgs as L, AgentRunErrorArgs as M, AgentRunEventArgs as N, AgentRunObserver as O, AgentRunPromptRef as P, AgentRunStartArgs as Q, AgentToolEndArgs as R, AgentToolErrorArgs as S, AgentToolObserver as T, AgentToolStartArgs as U, AgentToolStreamEventArgs as V, AgentTraceInfo as W, AgentTraceOptions as X, AgentApprovalRequiredEvent as a, AgentApprovalRequiredResult as b, AgentBlockedResult as c, AgentChildStreamEvent as d, AgentDeltaEvent as e, AgentErrorEvent as f, AgentErrorStreamEvent as g, AgentFinishEvent as h, AgentInput as i, AgentLifecycle as j, AgentMemoryCompactionEvent as k, AgentPrompt as l, AgentResponse as m, AgentResult as n, AgentRunOptions as o, AgentRunSettings as p, AgentStartEvent as q, AgentSteerInput as r, AgentStepFinishEvent as s, AgentStream as t, AgentStreamEvent as u, AgentToolApprovalRequest as v, AgentToolCallDeltaEvent as w, AgentToolFinishEvent as x, AgentToolStartEvent as y, AgentGenerationEndArgs as z };

package/dist/types-BVzM4RsC.d.ts

@@ -0,0 +1,155 @@
+import { U as Usage, J as JsonObject, M as Message, S as SystemMessage, C as CompletionModel } from './types-CQ_ioXWK.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 };