@anvia/core 0.26.0 → 1.0.0-rc.10

package/dist/types-DgvozfPc.d.ts

@@ -0,0 +1,349 @@
+import { M as ModelCallOptions } from './model-call-options-CZkSw_xN.js';
+
+type JsonPrimitive = string | number | boolean | null;
+type JsonValue = JsonPrimitive | JsonObject | readonly JsonValue[];
+type JsonObject = {
+    [key: string]: JsonValue;
+};
+type Document = {
+    id: string;
+    text: string;
+    additionalProps?: Record<string, string>;
+};
+type TextPart = Readonly<{
+    type: "text";
+    text: string;
+    signature?: string;
+}>;
+type ImageDetail = "auto" | "low" | "high";
+type FileData = Readonly<{
+    type: "url";
+    url: string;
+}> | Readonly<{
+    type: "data";
+    data: string;
+}> | Readonly<{
+    type: "text";
+    text: string;
+}>;
+type ImagePart = Readonly<{
+    type: "image";
+    image: Exclude<FileData, Readonly<{
+        type: "text";
+        text: string;
+    }>>;
+    mediaType?: string;
+    detail?: ImageDetail;
+}>;
+type FilePart = Readonly<{
+    type: "file";
+    data: FileData;
+    mediaType: string;
+    filename?: string;
+}>;
+type ReasoningPart = Readonly<{
+    type: "reasoning";
+    text: string;
+    id?: string;
+    details?: readonly ReasoningDetail[];
+}>;
+type ReasoningDetail = Readonly<{
+    type: "text";
+    text: string;
+    signature?: string;
+}> | Readonly<{
+    type: "summary";
+    text: string;
+}> | Readonly<{
+    type: "encrypted";
+    data: string;
+}> | Readonly<{
+    type: "redacted";
+    data: string;
+}>;
+type ReasoningContentType = ReasoningDetail["type"];
+type ToolCallPart = Readonly<{
+    type: "tool-call";
+    toolCallId: string;
+    callId?: string;
+    toolName: string;
+    input: JsonValue;
+    signature?: string;
+}>;
+type ToolResultContentPart = TextPart | FilePart;
+type ToolResultOutput = Readonly<{
+    type: "text";
+    value: string;
+}> | Readonly<{
+    type: "json";
+    value: JsonValue;
+}> | Readonly<{
+    type: "content";
+    value: readonly ToolResultContentPart[];
+}> | Readonly<{
+    type: "execution-denied";
+    reason?: string;
+}> | Readonly<{
+    type: "error-text";
+    value: string;
+}> | Readonly<{
+    type: "error-json";
+    value: JsonValue;
+}>;
+type ToolResultPart = Readonly<{
+    type: "tool-result";
+    toolCallId: string;
+    callId?: string;
+    toolName: string;
+    output: ToolResultOutput;
+}>;
+type ToolApprovalResponsePart = Readonly<{
+    type: "tool-approval-response";
+    interactionId: string;
+    toolCallId: string;
+    callId?: string;
+    toolName: string;
+    approved: boolean;
+    reason?: string;
+}>;
+type ToolQuestionAnswer = Readonly<{
+    questionId: string;
+    value: string;
+}>;
+type ToolQuestionResponsePart = Readonly<{
+    type: "tool-question-response";
+    interactionId: string;
+    toolCallId: string;
+    callId?: string;
+    toolName: string;
+    answers: readonly ToolQuestionAnswer[];
+}>;
+type ToolInteractionResponsePart = ToolApprovalResponsePart | ToolQuestionResponsePart;
+type UserContentPart = TextPart | ImagePart | FilePart;
+type AssistantContentPart = TextPart | ImagePart | FilePart | ReasoningPart | ToolCallPart;
+type SystemMessage<Metadata extends JsonObject = JsonObject> = Readonly<{
+    role: "system";
+    content: string;
+    metadata?: Metadata;
+}>;
+type UserMessage<Metadata extends JsonObject = JsonObject> = Readonly<{
+    role: "user";
+    content: string | readonly UserContentPart[];
+    metadata?: Metadata;
+}>;
+type AssistantMessage<Metadata extends JsonObject = JsonObject> = Readonly<{
+    role: "assistant";
+    id?: string;
+    content: string | readonly AssistantContentPart[];
+    metadata?: Metadata;
+}>;
+type ToolMessage<Metadata extends JsonObject = JsonObject> = Readonly<{
+    role: "tool";
+    content: readonly (ToolResultPart | ToolInteractionResponsePart)[];
+    metadata?: Metadata;
+}>;
+type Message<Metadata extends JsonObject = JsonObject> = SystemMessage<Metadata> | UserMessage<Metadata> | AssistantMessage<Metadata> | ToolMessage<Metadata>;
+declare function reasoningDisplayText(reasoning: ReasoningPart | readonly ReasoningDetail[]): string;
+type ToolChoice = "auto" | "required" | "none" | {
+    type: "function";
+    name: string;
+};
+type ToolDefinition = {
+    name: string;
+    description: string;
+    parameters: JsonObject;
+};
+/**
+ * A tool executed by the model provider rather than by Anvia's local tool runtime.
+ *
+ * Provider packages expose typed factories for these values. Application code can
+ * pass them through the same high-level `tools` APIs used for local tools.
+ */
+type ProviderTool = {
+    kind: "provider";
+    provider: string;
+    name: string;
+    configuration?: JsonObject;
+};
+type CompletionTool = ToolDefinition | ProviderTool;
+declare function isProviderTool(value: unknown): value is ProviderTool;
+type CompletionSource = {
+    type: "url";
+    url: string;
+    title?: string;
+    id?: string;
+    startIndex?: number;
+    endIndex?: number;
+};
+type ProviderToolCall = {
+    id: string;
+    name: string;
+    status?: string;
+    details?: JsonObject;
+};
+/**
+ * Provider-normalized, mutually exclusive usage buckets.
+ *
+ * Every token should appear in exactly one non-total bucket. `total` is the
+ * only aggregate key and should equal the sum of the other buckets.
+ */
+type UsageDetails = Record<string, number>;
+type ModelContextLimits = {
+    contextWindow: number;
+    maxInputTokens?: number;
+    maxOutputTokens?: number;
+};
+type CompletionModelInfo = {
+    modelId: string;
+    context: ModelContextLimits;
+};
+type ContextUsage = {
+    model: CompletionModelInfo;
+    usedTokens: number;
+    remainingTokens: number;
+    usedPercent: number;
+    remainingPercent: number;
+};
+declare function calculateContextUsage(usage: Usage, model: CompletionModelInfo | undefined): ContextUsage | undefined;
+declare function withContextUsage<RawResponse>(response: CompletionResponse<RawResponse>, model: CompletionModelInfo | undefined): CompletionResponse<RawResponse>;
+declare function resolveModelContextLimits(modelId: string, catalog: Readonly<Record<string, ModelContextLimits>>, override?: ModelContextLimits): ModelContextLimits | undefined;
+type AssistantGenerationMetadata = {
+    provider: string;
+    modelId: string;
+    usage: Usage;
+    finishReason?: CompletionFinishReason;
+    providerFinishReason?: string;
+    contextUsage?: ContextUsage;
+    sources?: CompletionSource[];
+    providerToolCalls?: ProviderToolCall[];
+};
+type Usage = {
+    inputTokens: number;
+    outputTokens: number;
+    totalTokens: number;
+    cachedInputTokens: number;
+    cacheCreationInputTokens: number;
+    details?: UsageDetails;
+};
+declare const Usage: {
+    empty(): Usage;
+    add(left: Usage, right: Usage): Usage;
+    isEmpty(usage: Usage): boolean;
+};
+declare function getAssistantGenerationMetadata(message: Message): AssistantGenerationMetadata | undefined;
+type CompletionRequest = {
+    instructions?: string;
+    chatHistory: Message[];
+    documents: Document[];
+    tools: ToolDefinition[];
+    providerTools?: ProviderTool[];
+    temperature?: number;
+    maxTokens?: number;
+    toolChoice?: ToolChoice;
+    providerOptions?: JsonObject;
+    outputSchema?: JsonObject;
+};
+type CompletionFinishReason = "stop" | "length" | "content-filter" | "tool-calls" | "other";
+type CompletionResponse<RawResponse = unknown> = {
+    choice: AssistantContentPart[];
+    usage: Usage;
+    finishReason?: CompletionFinishReason;
+    providerFinishReason?: string;
+    contextUsage?: ContextUsage;
+    rawResponse: RawResponse;
+    messageId?: string;
+    sources?: CompletionSource[];
+    providerToolCalls?: ProviderToolCall[];
+};
+type CompletionResult<Output = string, RawResponse = unknown> = {
+    output: Output;
+    text: string;
+    content: readonly AssistantContentPart[];
+    usage: Usage;
+    finishReason?: CompletionFinishReason;
+    providerFinishReason?: string;
+    contextUsage?: ContextUsage;
+    rawResponse: RawResponse;
+    messageId?: string;
+    sources?: readonly CompletionSource[];
+    providerToolCalls?: readonly ProviderToolCall[];
+};
+type CompletionModelCapabilities = {
+    streaming: boolean;
+    tools: boolean;
+    toolChoice: boolean;
+    imageInput: boolean;
+    documentInput: boolean;
+    outputSchema: boolean;
+    reasoning: boolean;
+    providerTools?: boolean;
+};
+interface CompletionModel<RawResponse = unknown> {
+    readonly provider: string;
+    readonly modelId: string;
+    readonly contextLimits?: ModelContextLimits | undefined;
+    readonly capabilities: CompletionModelCapabilities;
+    traceRequest?(request: CompletionRequest, options?: {
+        stream?: boolean | undefined;
+    }): JsonObject | undefined;
+    completion(request: CompletionRequest, options?: ModelCallOptions): Promise<CompletionResponse<RawResponse>>;
+}
+type ToolCallArgumentsMode = "append" | "replace";
+type CompletionStreamPart = {
+    type: "text_delta";
+    delta: string;
+} | {
+    type: "reasoning_delta";
+    delta: string;
+    id?: string;
+    contentType?: ReasoningContentType;
+    signature?: string;
+} | {
+    type: "tool_call_delta";
+    id: string;
+    callId?: string;
+    name?: string;
+    argumentsDelta?: string;
+    argumentsMode?: ToolCallArgumentsMode;
+    signature?: string;
+} | {
+    type: "tool_call";
+    toolCall: ToolCallPart;
+} | {
+    type: "source";
+    source: CompletionSource;
+} | {
+    type: "provider_tool_call";
+    toolCall: ProviderToolCall;
+} | {
+    type: "message_id";
+    id: string;
+};
+type CompletionModelStreamEvent<RawResponse = unknown> = CompletionStreamPart | {
+    type: "final";
+    response: CompletionResponse<RawResponse>;
+} | {
+    type: "error";
+    error: unknown;
+    usage?: Usage;
+};
+type CompletionStreamEvent<Output = string, RawResponse = unknown> = CompletionStreamPart | {
+    type: "final";
+    result: CompletionResult<Output, RawResponse>;
+} | {
+    type: "error";
+    error: unknown;
+    usage: Usage;
+};
+interface StreamingCompletionModel<RawResponse = unknown> extends CompletionModel<RawResponse> {
+    streamCompletion(request: CompletionRequest, options?: ModelCallOptions): AsyncIterable<CompletionModelStreamEvent<RawResponse>>;
+}
+declare class CompletionCapabilityError extends Error {
+    constructor(message: string);
+}
+declare function assertCompletionRequestSupported(model: CompletionModel, request: CompletionRequest, options?: {
+    streaming?: boolean | undefined;
+}): void;
+declare function textFromAssistantContent(content: readonly AssistantContentPart[]): string;
+
+export { type ToolQuestionAnswer as $, type AssistantContentPart as A, type ToolResultPart as B, type CompletionFinishReason as C, type Document as D, type UserContentPart as E, type FileData as F, type UserMessage as G, calculateContextUsage as H, type ImageDetail as I, type JsonObject as J, getAssistantGenerationMetadata as K, isProviderTool as L, type Message as M, resolveModelContextLimits as N, withContextUsage as O, type ProviderTool as P, CompletionCapabilityError as Q, type ReasoningContentType as R, type SystemMessage as S, type TextPart as T, Usage as U, type CompletionModelCapabilities as V, type CompletionStreamPart as W, type StreamingCompletionModel as X, type ToolApprovalResponsePart as Y, type ToolCallArgumentsMode as Z, type ToolInteractionResponsePart as _, type AssistantGenerationMetadata as a, type ToolQuestionResponsePart as a0, type UsageDetails as a1, assertCompletionRequestSupported as a2, reasoningDisplayText as a3, textFromAssistantContent as a4, type AssistantMessage as b, type CompletionModel as c, type CompletionModelInfo as d, type CompletionModelStreamEvent as e, type CompletionRequest as f, type CompletionResponse as g, type CompletionResult as h, type CompletionSource as i, type CompletionStreamEvent as j, type CompletionTool as k, type ContextUsage as l, type FilePart as m, type ImagePart as n, type JsonPrimitive as o, type JsonValue as p, type ModelContextLimits as q, type ProviderToolCall as r, type ReasoningDetail as s, type ReasoningPart as t, type ToolCallPart as u, type ToolChoice as v, type ToolDefinition as w, type ToolMessage as x, type ToolResultContentPart as y, type ToolResultOutput as z };

package/dist/types-DhkodEft.d.ts

@@ -0,0 +1,105 @@
+import { M as Message, J as JsonObject, U as Usage } from './types-DgvozfPc.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 };

package/dist/types-DjqRHeAi.d.ts

@@ -0,0 +1,31 @@
+import { J as JsonObject } from './types-DgvozfPc.js';
+import { A as AnyTool } from './tool-BpqpoRSE.js';
+
+type McpServerInfo = {
+    readonly name: string;
+    readonly version: string;
+    readonly title?: string | undefined;
+    readonly description?: string | undefined;
+    readonly websiteUrl?: string | undefined;
+    readonly icons?: readonly {
+        readonly src: string;
+        readonly mimeType?: string | undefined;
+        readonly sizes?: readonly string[] | undefined;
+        readonly theme?: "light" | "dark" | undefined;
+    }[];
+};
+type McpTool = AnyTool & {
+    readonly mcp: {
+        readonly serverName: string;
+        readonly remoteName: string;
+    };
+};
+type McpServer = {
+    readonly name: string;
+    readonly tools: readonly McpTool[];
+    readonly serverInfo?: McpServerInfo | undefined;
+    readonly capabilities?: JsonObject | undefined;
+    readonly instructions?: string | undefined;
+};
+
+export type { McpTool as M, McpServer as a, McpServerInfo as b };