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

package/dist/types-C3gv9EX6.d.ts

@@ -0,0 +1,130 @@
+import { b as RetrySetting } from './retry-CjvSlKGW.js';
+import { J as JsonObject } from './types-D9rKQ_as.js';
+import { b as VectorMetadataValue, V as VectorMetadata, a as EmbeddedDocument, S as SparseVector, E as EmbeddingModel, c as SparseEmbeddingModel } from './types-Cr4uiYo5.js';
+
+type VectorFilter = {
+    type: "eq";
+    key: string;
+    value: VectorMetadataValue;
+} | {
+    type: "gt";
+    key: string;
+    value: VectorMetadataValue;
+} | {
+    type: "lt";
+    key: string;
+    value: VectorMetadataValue;
+} | {
+    type: "and";
+    filters: [VectorFilter, VectorFilter];
+} | {
+    type: "or";
+    filters: [VectorFilter, VectorFilter];
+};
+type VectorMetric = "cosine" | "euclidean" | "dotProduct";
+type VectorFusion = "rrf" | "dbsf";
+type LshOptions = {
+    type: "lsh";
+    numTables: number;
+    numHyperplanes: number;
+    seed?: number | undefined;
+};
+type IndexStrategy = {
+    type: "bruteForce";
+} | LshOptions;
+type VectorStoreUpsertOptions<T, Metadata extends VectorMetadata = VectorMetadata> = {
+    documents: Array<EmbeddedDocument<T, Metadata>>;
+    providerOptions?: JsonObject | undefined;
+};
+type VectorSearchRequest = {
+    vector: number[];
+    topK: number;
+    minScore?: number | undefined;
+    filter?: VectorFilter | undefined;
+    providerOptions?: JsonObject | undefined;
+    abortSignal?: AbortSignal | undefined;
+};
+type HybridVectorSearchRequest = VectorSearchRequest & {
+    sparseVector: SparseVector;
+    fusion?: VectorFusion | undefined;
+};
+type VectorSearchResult<T = unknown, Metadata extends VectorMetadata = VectorMetadata> = {
+    score: number;
+    id: string;
+    document: T;
+    metadata?: Metadata | undefined;
+};
+type VectorInspectRequest = {
+    limit: number;
+    cursor?: string | undefined;
+    filter?: VectorFilter | undefined;
+    providerOptions?: JsonObject | undefined;
+    abortSignal?: AbortSignal | undefined;
+};
+type VectorInspectItem<T = unknown, Metadata extends VectorMetadata = VectorMetadata> = {
+    id: string;
+    document: T;
+    metadata?: Metadata | undefined;
+};
+type VectorInspectPage<T = unknown, Metadata extends VectorMetadata = VectorMetadata> = {
+    items: Array<VectorInspectItem<T, Metadata>>;
+    nextCursor?: string | undefined;
+    totalCount?: number | undefined;
+};
+interface VectorStore<T = unknown, Metadata extends VectorMetadata = VectorMetadata> {
+    ensure(): Promise<void>;
+    validate(): Promise<void>;
+    upsert(options: VectorStoreUpsertOptions<T, Metadata>): Promise<void>;
+    search(request: VectorSearchRequest): Promise<Array<VectorSearchResult<T, Metadata>>>;
+    inspect?(request: VectorInspectRequest): Promise<VectorInspectPage<T, Metadata>>;
+}
+interface HybridVectorStore<T = unknown, Metadata extends VectorMetadata = VectorMetadata> extends VectorStore<T, Metadata> {
+    searchHybrid(request: HybridVectorSearchRequest): Promise<Array<VectorSearchResult<T, Metadata>>>;
+}
+type RetrieveDocumentsBaseOptions = {
+    query: string;
+    topK: number;
+    minScore?: number | undefined;
+    filter?: VectorFilter | undefined;
+    retries?: RetrySetting | undefined;
+    abortSignal?: AbortSignal | undefined;
+};
+type RetrieveDocumentsOptions<T, Metadata extends VectorMetadata = VectorMetadata> = RetrieveDocumentsBaseOptions & {
+    store: VectorStore<T, Metadata>;
+    model: EmbeddingModel;
+    models?: never;
+};
+type RetrieveHybridDocumentsOptions<T, Metadata extends VectorMetadata = VectorMetadata> = RetrieveDocumentsBaseOptions & {
+    store: HybridVectorStore<T, Metadata>;
+    model?: never;
+    models: {
+        dense: EmbeddingModel;
+        sparse: SparseEmbeddingModel;
+    };
+    fusion?: VectorFusion | undefined;
+};
+type VectorSearchToolBaseOptions = {
+    name: string;
+    description?: string | undefined;
+    topK?: number | undefined;
+    minScore?: number | undefined;
+    filter?: VectorFilter | undefined;
+    retries?: RetrySetting | undefined;
+};
+type DenseVectorSearchToolOptions<T, Metadata extends VectorMetadata = VectorMetadata> = VectorSearchToolBaseOptions & {
+    store: VectorStore<T, Metadata>;
+    model: EmbeddingModel;
+    models?: never;
+};
+type HybridVectorSearchToolOptions<T, Metadata extends VectorMetadata = VectorMetadata> = VectorSearchToolBaseOptions & {
+    store: HybridVectorStore<T, Metadata>;
+    model?: never;
+    models: {
+        dense: EmbeddingModel;
+        sparse: SparseEmbeddingModel;
+    };
+    fusion?: VectorFusion | undefined;
+};
+type VectorSearchToolOptions<T = unknown, Metadata extends VectorMetadata = VectorMetadata> = DenseVectorSearchToolOptions<T, Metadata> | HybridVectorSearchToolOptions<T, Metadata>;
+
+export type { DenseVectorSearchToolOptions as D, HybridVectorStore as H, IndexStrategy as I, LshOptions as L, RetrieveDocumentsOptions as R, VectorFilter as V, VectorSearchResult as a, VectorInspectRequest as b, VectorInspectPage as c, VectorStore as d, VectorFusion as e, RetrieveHybridDocumentsOptions as f, VectorStoreUpsertOptions as g, VectorSearchRequest as h, VectorSearchToolOptions as i, HybridVectorSearchRequest as j, HybridVectorSearchToolOptions as k, RetrieveDocumentsBaseOptions as l, VectorInspectItem as m, VectorMetric as n, VectorSearchToolBaseOptions as o };

package/dist/{index-DxB74ybJ.d.ts → types-CElwurHZ.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 { GuardrailPolicyInput, GuardrailDecisionRecord } from './guardrails/index.js';
-import { A as AgentMiddleware } from './middleware-KynLg_RW.js';
+import { a as AgentInteractionRequest, A as AgentContinuation, b as AgentInteractionResponse, c as AgentMiddleware } from './interactions-csssHYcN.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, Z as ToolInteractionResponsePart, Y as ToolCallArgumentsMode, J as JsonObject, Q as CompletionModelCapabilities, v as ToolDefinition } from './types-D9rKQ_as.js';
+import { d as GuardrailPolicyInput, a as GuardrailDecisionRecord } from './types-CIPaIbZo.js';
+import { e as MemoryCompactionInfo, z as MemoryScope } from './types-DbolvLtZ.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-r62gf3QY.js';
 
 type AgentLifecycleRunEvent = {
     runId: string;
@@ -34,39 +35,81 @@ 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 AgentRunLink = Readonly<{
+    runId: string;
+    interactionId: string;
+}>;
+type AgentResultBase = {
     runId: string;
-    output: string;
+    text: string;
     usage: Usage;
     contextUsage?: ContextUsage | undefined;
     messages: Message[];
@@ -74,32 +117,23 @@ type AgentResponse = {
     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> = AgentResultBase & {
+    status: "completed";
+    output: Output;
 };
-type AgentApprovalRequiredEvent = Omit<AgentApprovalRequiredResult, "status"> & {
-    type: "approval_required";
+type AgentBlockedResult = AgentResultBase & {
+    status: "blocked";
+    stage: "input" | "output";
 };
-type AgentApprovalDecision = {
-    approved: true;
-    reason?: string;
-} | {
-    approved: false;
-    reason?: string;
+type AgentSuspendedResult = AgentResultBase & {
+    status: "suspended";
+    interaction: AgentInteractionRequest;
+    continuation: AgentContinuation;
 };
+type AgentResult<Output = string> = AgentResponse<Output> | AgentBlockedResult | AgentSuspendedResult;
 type AgentDeltaEvent = {
     type: "text_delta";
     delta: string;
@@ -111,7 +145,7 @@ type AgentDeltaEvent = {
     signature?: string;
 } | {
     type: "tool_call";
-    toolCall: ToolCall;
+    toolCall: ToolCallPart;
 } | {
     type: "source";
     source: CompletionSource;
@@ -124,10 +158,6 @@ type AgentErrorStreamEvent = {
     error: unknown;
     usage: Usage;
 };
-type AgentStreamOptions = AgentRunOptions & {
-    /** @default true */
-    includeToolCallDeltas?: boolean;
-};
 type AgentToolCallDeltaEvent = {
     type: "tool_call_delta";
     turn: number;
@@ -138,7 +168,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 +209,7 @@ type AgentChildStreamEventBase<RawResponse = unknown> = {
 } | {
     type: "tool_call";
     turn: number;
-    toolCall: ToolCall;
+    toolCall: ToolCallPart;
 } | {
     type: "source";
     turn: number;
@@ -175,11 +222,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 +238,12 @@ type AgentChildStreamEventBase<RawResponse = unknown> = {
     type: "guardrail_decision";
     turn?: number | undefined;
     decision: GuardrailDecisionRecord;
-} | {
+} | AgentMemoryCompactionEvent | AgentInteractionResponseEvent | AgentSteeringAppliedEvent | {
     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> = {
+    result: AgentResult<Output>;
+} | AgentErrorStreamEvent;
+type AgentChildStreamEvent<Output = string, RawResponse = unknown> = AgentChildStreamEventBase<Output, RawResponse> | AgentToolCallDeltaEvent;
+type AgentToolStreamEvent = {
     type: "agent_tool_event";
     turn: number;
     toolName: string;
@@ -212,28 +251,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): 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?: 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 +289,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 +315,7 @@ type AgentRunErrorArgs = {
 };
 type AgentGenerationModelInfo = {
     readonly provider: string;
-    readonly defaultModel: string;
+    readonly modelId: string;
     readonly capabilities?: DeepReadonly<CompletionModelCapabilities> | undefined;
 };
 type AgentGenerationStartArgs = {
@@ -289,13 +339,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 +355,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 +375,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 +388,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 { 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/types-CIPaIbZo.d.ts

@@ -0,0 +1,105 @@
+import { M as Message, J as JsonObject, U as Usage } from './types-D9rKQ_as.js';
+import { M as MaybePromise } from './type-utils-CtHVDRn_.js';
+
+type GuardrailMode = "enforce" | "observe";
+type GuardrailBoundary = "input" | "output";
+type GuardrailRunContext = {
+    agentId: string;
+    runId: string;
+    sessionId?: string | undefined;
+    metadata?: JsonObject | undefined;
+};
+type GuardrailDecisionRecord = {
+    policyId: string;
+    guardrailId: string;
+    boundary: GuardrailBoundary;
+    mode: GuardrailMode;
+    action: GuardrailActionName;
+    applied: boolean;
+    reason?: string | undefined;
+    message?: string | undefined;
+    metadata?: JsonObject | undefined;
+    latencyMs: number;
+};
+type GuardrailActionName = "allow" | "block" | "rewrite" | "error";
+type GuardrailActionBase = {
+    reason?: string | undefined;
+    metadata?: JsonObject | undefined;
+};
+type GuardrailAllow = GuardrailActionBase & {
+    action: "allow";
+};
+type GuardrailBlock = GuardrailActionBase & {
+    action: "block";
+    reason: string;
+    message?: string | undefined;
+};
+type InputGuardrailRewrite = GuardrailActionBase & {
+    action: "rewrite";
+    prompt?: Message | undefined;
+    inputText?: string | undefined;
+};
+type OutputGuardrailRewrite = GuardrailActionBase & {
+    action: "rewrite";
+    outputText: string;
+};
+type InputGuardrailResult = GuardrailAllow | GuardrailBlock | InputGuardrailRewrite;
+type OutputGuardrailResult = GuardrailAllow | GuardrailBlock | OutputGuardrailRewrite;
+type GuardrailCommonActions = {
+    allow(options?: GuardrailActionBase): GuardrailAllow;
+    block(options: Omit<GuardrailBlock, "action">): GuardrailBlock;
+};
+type InputGuardrailActions = GuardrailCommonActions & {
+    rewrite(options: Omit<InputGuardrailRewrite, "action">): InputGuardrailRewrite;
+};
+type OutputGuardrailActions = GuardrailCommonActions & {
+    rewrite(options: Omit<OutputGuardrailRewrite, "action">): OutputGuardrailRewrite;
+};
+type InputGuardrailContext = {
+    prompt: Message;
+    history: Message[];
+    inputText: string;
+    run: GuardrailRunContext;
+};
+type OutputGuardrailContext = {
+    outputText: string;
+    messages: Message[];
+    usage: Usage;
+    run: GuardrailRunContext;
+};
+type InputGuardrail = {
+    id: string;
+    check(context: InputGuardrailContext, actions: InputGuardrailActions): MaybePromise<InputGuardrailResult | undefined>;
+};
+type OutputGuardrail = {
+    id: string;
+    check(context: OutputGuardrailContext, actions: OutputGuardrailActions): MaybePromise<OutputGuardrailResult | undefined>;
+};
+type GuardrailPolicy = {
+    id: string;
+    mode: GuardrailMode;
+    input: InputGuardrail[];
+    output: OutputGuardrail[];
+};
+type GuardrailPolicyOptions = {
+    id: string;
+    mode?: GuardrailMode | undefined;
+    input?: InputGuardrail[] | undefined;
+    output?: OutputGuardrail[] | undefined;
+};
+type GuardrailPolicyInput = GuardrailPolicy | GuardrailPolicy[];
+type InputGuardrailRunResult = {
+    prompt: Message;
+    inputText: string;
+    blocked: boolean;
+    message?: string | undefined;
+    decisions: GuardrailDecisionRecord[];
+};
+type OutputGuardrailRunResult = {
+    outputText: string;
+    blocked: boolean;
+    message?: string | undefined;
+    decisions: GuardrailDecisionRecord[];
+};
+
+export type { GuardrailBoundary as G, InputGuardrail as I, OutputGuardrail as O, GuardrailDecisionRecord as a, GuardrailMode as b, GuardrailPolicy as c, GuardrailPolicyInput as d, GuardrailPolicyOptions as e, InputGuardrailActions as f, InputGuardrailContext as g, OutputGuardrailActions as h, OutputGuardrailContext as i, InputGuardrailRunResult as j, OutputGuardrailRunResult as k, GuardrailActionBase as l, GuardrailActionName as m, GuardrailAllow as n, GuardrailBlock as o, GuardrailCommonActions as p, GuardrailRunContext as q, InputGuardrailResult as r, InputGuardrailRewrite as s, OutputGuardrailResult as t, OutputGuardrailRewrite as u };