@anvia/core 0.26.0 → 1.0.0-rc.2

package/dist/types-3x3mOLHU.d.ts

@@ -0,0 +1,379 @@
+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 { 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--Mz4v1eL.js';
+import { A as AgentMiddleware } from './middleware-C7PdmKF7.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";
+});
+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;
+} | {
+    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?: 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 AgentResultBase = {
+    runId: string;
+    text: string;
+    usage: Usage;
+    contextUsage?: ContextUsage | undefined;
+    messages: Message[];
+    trace?: AgentTraceInfo | undefined;
+    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";
+    runId: string;
+    approval: AgentToolApprovalRequest;
+    usage: Usage;
+    messages: Message[];
+    memoryCompaction?: MemoryCompactionInfo | undefined;
+};
+type AgentResult<Output = string> = AgentResponse<Output> | AgentBlockedResult | AgentApprovalRequiredResult;
+type AgentToolApprovalRequest = {
+    id: string;
+    toolName: string;
+    toolCallId?: string | undefined;
+    reason?: string | undefined;
+    input: unknown;
+};
+type AgentApprovalRequiredEvent = Omit<AgentApprovalRequiredResult, "status"> & {
+    type: "approval_required";
+};
+type AgentApprovalDecision = {
+    approved: true;
+    reason?: string;
+} | {
+    approved: false;
+    reason?: string;
+};
+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 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 | {
+    type: "final";
+    result: AgentResponse<Output> | AgentBlockedResult;
+} | AgentApprovalRequiredEvent | 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): 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?: 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 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>;
+    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 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>;
+    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 { 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 };