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

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

@@ -1,9 +1,11 @@
-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 { GuardrailPolicyInput, GuardrailDecisionRecord } from './guardrails/index.js';
-import { A as AgentMiddleware } from './middleware-KynLg_RW.js';
+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, A as MemoryScope } from './types-CSYt7-It.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-BpqpoRSE.js';
+import { A as AgentMiddleware } from './middleware-kcF8AusP.js';
 
 type AgentLifecycleRunEvent = {
     runId: string;
@@ -34,72 +36,113 @@ 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";
+}) | (AgentFinishEventBase & {
+    status: "suspended";
+    interaction: DeepReadonly<AgentInteractionRequest>;
+});
 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;
+    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?: 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 AgentMemoryCompactionOptions = {
+    session: MemoryScope;
+    abortSignal?: AbortSignal | undefined;
+};
+type AgentRunLink = Readonly<{
+    runId: string;
+    interactionId: string;
+}>;
+type AgentOutcomeBase = {
     runId: string;
-    output: 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 AgentApprovalRequiredResult = {
-    status: "approval_required";
-    runId: string;
-    approval: AgentToolApprovalRequest;
-    usage: Usage;
-    messages: Message[];
-};
-type AgentResult = AgentResponse | AgentApprovalRequiredResult;
-type AgentToolApprovalRequest = {
-    id: string;
-    toolName: string;
-    toolCallId?: string | undefined;
-    reason?: string | undefined;
-    input: unknown;
+type AgentResponse<Output = string> = AgentOutcomeBase & {
+    type: "response";
+    output: Output;
 };
-type AgentApprovalRequiredEvent = Omit<AgentApprovalRequiredResult, "status"> & {
-    type: "approval_required";
+type AgentBlockedOutcome = AgentOutcomeBase & {
+    type: "blocked";
+    stage: "input" | "output";
+    reason: string;
+    message?: string | undefined;
 };
-type AgentApprovalDecision = {
-    approved: true;
-    reason?: string;
-} | {
-    approved: false;
-    reason?: string;
+type AgentInteractionOutcome = AgentOutcomeBase & {
+    type: "interaction";
+    interaction: AgentInteractionRequest;
+    continuation: AgentContinuation;
 };
+type AgentOutcome<Output = string> = AgentResponse<Output> | AgentBlockedOutcome | AgentInteractionOutcome;
 type AgentDeltaEvent = {
     type: "text_delta";
     delta: string;
@@ -111,7 +154,7 @@ type AgentDeltaEvent = {
     signature?: string;
 } | {
     type: "tool_call";
-    toolCall: ToolCall;
+    toolCall: ToolCallPart;
 } | {
     type: "source";
     source: CompletionSource;
@@ -124,10 +167,6 @@ type AgentErrorStreamEvent = {
     error: unknown;
     usage: Usage;
 };
-type AgentStreamOptions = AgentRunOptions & {
-    /** @default true */
-    includeToolCallDeltas?: boolean;
-};
 type AgentToolCallDeltaEvent = {
     type: "tool_call_delta";
     turn: number;
@@ -138,7 +177,24 @@ type AgentToolCallDeltaEvent = {
     argumentsMode?: ToolCallArgumentsMode;
     signature?: string;
 };
-type AgentChildStreamEventBase<RawResponse = unknown> = {
+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;
@@ -162,7 +218,7 @@ type AgentChildStreamEventBase<RawResponse = unknown> = {
 } | {
     type: "tool_call";
     turn: number;
-    toolCall: ToolCall;
+    toolCall: ToolCallPart;
 } | {
     type: "source";
     turn: number;
@@ -175,11 +231,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 +247,9 @@ type AgentChildStreamEventBase<RawResponse = unknown> = {
     type: "guardrail_decision";
     turn?: number | undefined;
     decision: GuardrailDecisionRecord;
-} | {
-    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;
-} | AgentApprovalRequiredEvent | AgentErrorStreamEvent;
-type AgentChildStreamEventWithoutToolCallDeltas<RawResponse = unknown> = AgentChildStreamEventBase<RawResponse>;
-type AgentChildStreamEvent<RawResponse = unknown> = AgentChildStreamEventBase<RawResponse> | AgentToolCallDeltaEvent;
-type AgentChildStreamEventWithToolCallDeltas<RawResponse = unknown> = AgentChildStreamEvent<RawResponse>;
-type AgentToolStreamEvent<ChildEvent> = {
+} | AgentMemoryCompactionEvent | AgentInteractionResponseEvent | AgentSteeringAppliedEvent | AgentOutcome<Output> | AgentErrorStreamEvent;
+type AgentChildStreamEvent<Output = string, RawResponse = unknown> = AgentChildStreamEventBase<Output, RawResponse> | AgentToolCallDeltaEvent;
+type AgentToolStreamEvent = {
     type: "agent_tool_event";
     turn: number;
     toolName: string;
@@ -212,28 +257,32 @@ type AgentToolStreamEvent<ChildEvent> = {
     internalCallId: string;
     agentId: string;
     agentName?: string;
-    event: ChildEvent;
-};
-type AgentStreamEventWithoutToolCallDeltas<RawResponse = unknown> = AgentChildStreamEventWithoutToolCallDeltas<RawResponse> | AgentToolStreamEvent<AgentChildStreamEventWithoutToolCallDeltas<RawResponse>>;
-type AgentStreamEvent<RawResponse = unknown> = AgentChildStreamEvent<RawResponse> | AgentToolStreamEvent<AgentChildStreamEvent<RawResponse>>;
-type AgentStreamEventWithToolCallDeltas<RawResponse = unknown> = AgentStreamEvent<RawResponse>;
-interface AgentStream<Event = AgentStreamEvent> extends AsyncIterable<Event> {
-    steer(input: AgentInput): boolean;
+    event: AgentChildStreamEvent<unknown, unknown>;
+};
+type AgentStreamEvent<Output = string, RawResponse = unknown> = AgentChildStreamEvent<Output, RawResponse> | AgentToolStreamEvent;
+interface AgentStream<Output = string, RawResponse = unknown> extends AsyncIterable<AgentStreamEvent<Output, RawResponse>> {
+    readonly events: AsyncIterable<AgentStreamEvent<Output, RawResponse>>;
+    readonly textStream: AsyncIterable<string>;
+    readonly text: Promise<string>;
+    readonly result: Promise<AgentOutcome<Output>>;
+    steer(input: AgentSteerInput): AgentSteerReceipt;
+    cancel(reason?: string): void;
 }
 
 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 +300,25 @@ type AgentRunStartArgs = {
     readonly history: readonly DeepReadonly<Message>[];
     readonly maxTurns: number;
 };
-type AgentRunEndArgs = {
-    readonly output: string;
+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>;
@@ -265,7 +326,7 @@ type AgentRunErrorArgs = {
 };
 type AgentGenerationModelInfo = {
     readonly provider: string;
-    readonly defaultModel: string;
+    readonly modelId: string;
     readonly capabilities?: DeepReadonly<CompletionModelCapabilities> | undefined;
 };
 type AgentGenerationStartArgs = {
@@ -289,13 +350,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,12 +366,15 @@ 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 & {
     readonly error: unknown;
 };
+type AgentToolSuspendedArgs = AgentToolStartArgs & {
+    readonly interaction: DeepReadonly<AgentInteractionRequest>;
+};
 type AgentToolStreamEventArgs = AgentToolStartArgs & {
     readonly event: DeepReadonly<ToolCallStreamEvent>;
 };
@@ -322,10 +386,11 @@ interface AgentGenerationObserver {
 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?: 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 +399,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 { AgentBlockedOutcome as A, AgentGenerationModelInfo as B, AgentGenerationObserver as C, AgentGenerationStartArgs as D, AgentGenerationUpdateArgs as E, AgentObservabilityOptions as F, AgentObserver as G, AgentObserverErrorPolicy as H, AgentObserverMap as I, AgentObserverTraceInfo as J, AgentRunEndArgs as K, AgentRunErrorArgs as L, AgentRunEventArgs as M, AgentRunObserver as N, AgentRunPromptRef as O, AgentRunStartArgs as P, AgentToolEndArgs as Q, AgentToolErrorArgs as R, AgentToolObserver as S, AgentToolStartArgs as T, AgentToolStreamEventArgs as U, AgentToolSuspendedArgs as V, AgentTraceInfo as W, AgentTraceOptions as X, AgentChildStreamEvent as a, AgentDeltaEvent as b, AgentErrorEvent as c, AgentErrorStreamEvent as d, AgentFinishEvent as e, AgentInput as f, AgentInteractionOutcome as g, AgentLifecycle as h, AgentMemoryCompactionEvent as i, AgentMemoryCompactionOptions as j, AgentOutcome as k, AgentPrompt as l, AgentResponse as m, AgentRunOptions as n, AgentRunSettings as o, AgentStartEvent as p, AgentSteerInput as q, AgentSteerReceipt as r, AgentStepFinishEvent as s, AgentStream as t, AgentStreamEvent as u, AgentToolCallDeltaEvent as v, AgentToolFinishEvent as w, AgentToolStartEvent as x, AgentGenerationEndArgs as y, AgentGenerationErrorArgs as z };

package/dist/types-CSYt7-It.d.ts

@@ -0,0 +1,170 @@
+import { U as Usage, J as JsonObject, M as Message, S as SystemMessage, c as CompletionModel } from './types-DgvozfPc.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>;
+/** Counts the approximate or exact model tokens represented by a message list. */
+type MemoryTokenCounter = (messages: readonly Message[]) => number | Promise<number>;
+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: {
+        afterTokens: number;
+    };
+    retention?: {
+        recentTokens?: number | undefined;
+    };
+    tokenCounter?: MemoryTokenCounter | undefined;
+    compactor: MemoryCompactor;
+    conflictRetries?: false | MemoryCompactionConflictRetryOptions | undefined;
+};
+type MemoryOptions = {
+    savePolicy?: MemorySavePolicy | undefined;
+    compaction?: MemoryCompactionOptions | undefined;
+};
+type MemoryCompactionInfo = {
+    originalMessageCount: number;
+    compactedMessageCount: number;
+    retainedMessageCount: number;
+    originalTokenCount: number;
+    compactedTokenCount: number;
+    retainedTokenCount: number;
+    resultTokenCount: number;
+    attempts: number;
+    usage: Usage;
+};
+type MemoryCompactionResult = ({
+    type: "compacted";
+} & MemoryCompactionInfo) | {
+    type: "skipped";
+    reason: "nothing_to_compact";
+    originalMessageCount: number;
+    originalTokenCount: number;
+};
+
+export type { MemoryScope as A, MemoryScopeKeyOptions as B, CreateMemoryScopeKeyOptions as C, MemoryScopeKeyResolver as D, MemoryStore as E, MemoryTokenCounter as F, 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, MemoryCompactionResult as k, MemoryCompactionSnapshot as l, MemoryCompactionSnapshotOptions as m, MemoryCompactor as n, MemoryCompactorInput as o, MemoryCompactorResult as p, MemoryConversation as q, MemoryConversationGetOptions as r, MemoryConversationListOptions as s, MemoryConversationMessage as t, MemoryConversationSummary as u, MemoryErrorOptions as v, MemoryInspector as w, MemoryLoadOptions as x, MemoryOptions as y, MemorySavePolicy as z };