@anvia/client 1.0.0-rc.10

package/dist/index.d.ts

@@ -0,0 +1,433 @@
+import { AgentStreamEvent } from '@anvia/core/agent';
+import { JsonValue, JsonObject, ReasoningContentType, ReasoningDetail, ToolResultContentPart, CompletionSource, ImageDetail, ProviderToolCall, Usage, ContextUsage, Message, CompletionStreamEvent } from '@anvia/core/completion';
+import { AgentInteractionRequest, AgentInteractionResponse } from '@anvia/core/agent/interactions';
+import { GuardrailDecisionRecord } from '@anvia/core/guardrails';
+import { MemoryCompactionInfo } from '@anvia/core/memory';
+import { C as CreateFetchEventTransportOptions } from './event-transport-CC5RD-hT.js';
+
+declare const CLIENT_STREAM_PROTOCOL: "anvia.client.v3";
+type ClientDataMap = Record<string, JsonValue>;
+type ClientMetadata = JsonObject;
+type ClientDataSchema<T extends JsonValue = JsonValue> = {
+    safeParse(value: unknown): {
+        success: true;
+        data: T;
+    } | {
+        success: false;
+        error?: unknown;
+    };
+};
+type ClientDataSchemas<TData extends ClientDataMap> = {
+    [Name in keyof TData]: ClientDataSchema<TData[Name]>;
+};
+type ClientMetadataSchema<TMetadata extends JsonObject = JsonObject> = ClientDataSchema<TMetadata>;
+type UIMessageRole = "system" | "user" | "assistant" | "tool";
+type ClientStreamError = {
+    name?: string;
+    message: string;
+    code?: string;
+    retryable?: boolean;
+    details?: JsonValue;
+};
+type UIError = ClientStreamError;
+type UIMessageGeneration = {
+    runId?: string;
+    status?: "completed" | "blocked" | "suspended" | "cancelled" | "error";
+    usage?: Usage;
+    contextUsage?: ContextUsage;
+    trace?: {
+        observer: string;
+        traceId?: string;
+        observationId?: string;
+    };
+    memoryCompaction?: MemoryCompactionInfo;
+};
+type UIMessage<Metadata extends JsonObject = JsonObject, Data extends ClientDataMap = ClientDataMap> = Readonly<{
+    id: string;
+    role: UIMessageRole;
+    parts: readonly UIMessagePart<Data>[];
+    modelMessageId?: string;
+    metadata?: Metadata;
+    generation?: UIMessageGeneration;
+}>;
+type UIAttachment = {
+    id: string;
+    type: "image" | "document" | "file";
+    name?: string;
+    mediaType?: string;
+    url?: string;
+    data?: string;
+    text?: string;
+    detail?: ImageDetail;
+    metadata?: JsonValue;
+};
+type CreateUIAttachment = Omit<UIAttachment, "id"> & {
+    id?: string;
+};
+type UIDataPart<Data extends ClientDataMap> = {
+    [Name in keyof Data & string]: {
+        id: string;
+        type: "data";
+        name: Name;
+        data: Data[Name];
+    };
+}[keyof Data & string];
+type UIToolMessagePartBase = {
+    id: string;
+    type: "tool";
+    toolName: string;
+    toolCallId: string;
+    callId?: string;
+    internalCallId?: string;
+    turn?: number;
+    signature?: string;
+};
+type UIToolMessagePart = (UIToolMessagePartBase & {
+    state: "input-streaming";
+    input: string;
+}) | (UIToolMessagePartBase & {
+    state: "input-available";
+    input: JsonValue;
+}) | (UIToolMessagePartBase & {
+    state: "output-available";
+    input: JsonValue;
+    output: JsonValue;
+    resultContent?: readonly ToolResultContentPart[];
+}) | (UIToolMessagePartBase & {
+    state: "error";
+    input: JsonValue;
+    error: UIError;
+});
+type UIMessagePart<Data extends ClientDataMap = ClientDataMap> = {
+    id: string;
+    type: "text";
+    text: string;
+    signature?: string;
+} | {
+    id: string;
+    type: "reasoning";
+    text: string;
+    reasoningId?: string;
+    content?: readonly ReasoningDetail[];
+} | UIToolMessagePart | {
+    id: string;
+    type: "source";
+    source: CompletionSource;
+} | UIDataPart<Data> | {
+    id: string;
+    type: "attachment";
+    attachment: UIAttachment;
+} | {
+    id: string;
+    type: "error";
+    error: UIError;
+};
+type ClientStreamCursor = {
+    streamId: string;
+    after: number;
+};
+type ClientStreamRequest<Metadata extends JsonObject = JsonObject> = {
+    type: "messages";
+    messages: readonly Message[];
+    metadata?: Metadata;
+    resume?: ClientStreamCursor;
+} | {
+    type: "interaction_response";
+    interactionId: string;
+    response: AgentInteractionResponse;
+    metadata?: Metadata;
+    resume?: ClientStreamCursor;
+};
+type ClientCompletionRequest<Metadata extends JsonObject = JsonObject> = {
+    prompt: string;
+    metadata?: Metadata;
+};
+type ClientStreamScope = {
+    agentId?: string;
+    agentName?: string;
+    parentRunId?: string;
+    parentToolName?: string;
+    parentToolCallId?: string;
+    parentInternalToolCallId?: string;
+};
+type ClientInteraction = Readonly<{
+    request: AgentInteractionRequest;
+    runId: string;
+    status: "pending" | "responded" | "cancelled";
+}>;
+type ClientStreamEventBase = {
+    runId: string;
+    turn?: number;
+    scope?: ClientStreamScope;
+};
+type ClientDataEvent<TData extends ClientDataMap> = {
+    [Name in keyof TData & string]: {
+        type: "data";
+        name: Name;
+        data: TData[Name];
+        transient?: boolean;
+    };
+}[keyof TData & string];
+type ClientStandardStreamEvent<Metadata extends JsonObject, Data extends ClientDataMap> = {
+    type: "run_start";
+    source: "completion" | "agent";
+    metadata?: Metadata;
+} | {
+    type: "turn_start";
+} | {
+    type: "generation_start";
+    model?: {
+        provider: string;
+        modelId: string;
+    };
+} | {
+    type: "message_start";
+    messageId: string;
+    role: "assistant";
+    metadata?: Metadata;
+} | {
+    type: "text_start";
+    messageId: string;
+    partId: string;
+} | {
+    type: "text_delta";
+    messageId: string;
+    partId: string;
+    delta: string;
+} | {
+    type: "text_end";
+    messageId: string;
+    partId: string;
+    text?: string;
+    signature?: string;
+} | {
+    type: "reasoning_start";
+    messageId: string;
+    partId: string;
+    reasoningId?: string;
+} | {
+    type: "reasoning_delta";
+    messageId: string;
+    partId: string;
+    delta: string;
+    contentType?: ReasoningContentType;
+    signature?: string;
+} | {
+    type: "reasoning_end";
+    messageId: string;
+    partId: string;
+    text?: string;
+    content?: readonly ReasoningDetail[];
+} | {
+    type: "tool_call_start";
+    messageId: string;
+    partId: string;
+    toolCallId: string;
+    callId?: string;
+    toolName?: string;
+} | {
+    type: "tool_call_delta";
+    messageId: string;
+    partId: string;
+    toolCallId: string;
+    callId?: string;
+    toolName?: string;
+    delta: string;
+    mode: "append" | "replace";
+    signature?: string;
+} | {
+    type: "tool_call_end";
+    messageId: string;
+    partId: string;
+    toolCallId: string;
+    callId?: string;
+    toolName: string;
+    input: JsonValue;
+    signature?: string;
+} | {
+    type: "tool_result";
+    messageId: string;
+    partId: string;
+    toolCallId: string;
+    callId?: string;
+    internalCallId?: string;
+    toolName: string;
+    input: JsonValue;
+    result: {
+        status: "success";
+        output: JsonValue;
+        content?: readonly ToolResultContentPart[];
+    } | {
+        status: "error";
+        error: ClientStreamError;
+    };
+} | {
+    type: "source";
+    messageId: string;
+    partId: string;
+    source: CompletionSource;
+} | {
+    type: "attachment";
+    messageId: string;
+    partId: string;
+    attachment: UIAttachment;
+} | {
+    type: "provider_tool_call";
+    toolCall: ProviderToolCall;
+} | {
+    type: "interaction";
+    interaction: AgentInteractionRequest;
+} | {
+    type: "guardrail_decision";
+    decision: GuardrailDecisionRecord;
+} | ({
+    type: "memory_compaction";
+} & MemoryCompactionInfo) | {
+    type: "message_end";
+    messageId: string;
+    modelMessageId?: string;
+    /** Authoritative model-authored parts after provider normalization and guardrails. */
+    parts?: readonly UIMessagePart<Data>[];
+    usage?: Usage;
+    contextUsage?: ContextUsage;
+    metadata?: Metadata;
+} | {
+    type: "turn_end";
+    usage?: Usage;
+    contextUsage?: ContextUsage;
+    firstDeltaMs?: number;
+} | {
+    type: "run_end";
+    status: "completed" | "blocked" | "suspended" | "cancelled" | "error";
+    text?: string;
+    output?: JsonValue;
+    usage?: Usage;
+    contextUsage?: ContextUsage;
+    trace?: {
+        observer: string;
+        traceId?: string;
+        observationId?: string;
+    };
+    memoryCompaction?: MemoryCompactionInfo;
+    metadata?: Metadata;
+} | {
+    type: "error";
+    error: ClientStreamError;
+    usage?: Usage;
+};
+type ClientStreamEvent<Metadata extends JsonObject = JsonObject, Data extends ClientDataMap = ClientDataMap> = ClientStreamEventBase & (ClientStandardStreamEvent<Metadata, Data> | ClientDataEvent<Data>);
+type ClientStream<Metadata extends JsonObject = JsonObject, Data extends ClientDataMap = ClientDataMap> = AsyncIterable<ClientStreamEvent<Metadata, Data>>;
+type ClientStreamFrame<Metadata extends JsonObject = JsonObject, Data extends ClientDataMap = ClientDataMap> = {
+    type: "stream_start";
+    protocol: typeof CLIENT_STREAM_PROTOCOL;
+    streamId: string;
+    eventId: 0;
+    resumable: boolean;
+} | {
+    type: "stream_event";
+    streamId: string;
+    eventId: number;
+    event: ClientStreamEvent<Metadata, Data>;
+} | {
+    type: "stream_end";
+    streamId: string;
+    eventId: number;
+    status: "completed" | "error" | "missing";
+};
+type ClientTransportSendOptions<TRequest> = {
+    request: TRequest;
+    abortSignal?: AbortSignal;
+    headers?: HeadersInit;
+    resume?: ClientStreamCursor;
+};
+type ClientTransport<TRequest = ClientStreamRequest, Data extends ClientDataMap = ClientDataMap, Metadata extends JsonObject = JsonObject> = {
+    readonly _types?: {
+        metadata: Metadata;
+        data: Data;
+    };
+    send(options: ClientTransportSendOptions<TRequest>): AsyncIterable<ClientStreamFrame<Metadata, Data>>;
+};
+type ClientErrorMapper = (error: unknown) => ClientStreamError;
+type ClientOutputMapper = (output: unknown) => JsonValue | undefined;
+
+type ClientStreamAdapterOptions<Metadata extends JsonObject = JsonObject> = {
+    /** Stable correlation ID for this client-visible run. */
+    runId?: string;
+    metadata?: Metadata;
+    mapError?: ClientErrorMapper;
+    mapOutput?: ClientOutputMapper;
+};
+type CompletionClientStreamOptions<Metadata extends JsonObject = JsonObject> = ClientStreamAdapterOptions<Metadata> & {
+    model?: {
+        provider: string;
+        modelId: string;
+    };
+};
+type AgentClientStreamContext = {
+    runId: string;
+    turn?: number;
+    scope?: ClientStreamScope;
+};
+type AgentClientStreamOptions<CustomEvent = unknown, Metadata extends JsonObject = JsonObject, Data extends ClientDataMap = ClientDataMap> = ClientStreamAdapterOptions<Metadata> & {
+    mapCustomEvent?: (event: CustomEvent, context: AgentClientStreamContext) => ClientStreamEvent<Metadata, Data> | readonly ClientStreamEvent<Metadata, Data>[] | undefined;
+};
+declare function completionToClientStream<Output = string, RawResponse = unknown, Metadata extends JsonObject = JsonObject>(options: CompletionClientStreamOptions<Metadata> & {
+    events: AsyncIterable<CompletionStreamEvent<Output, RawResponse>>;
+}): ClientStream<Metadata>;
+declare function agentToClientStream<Output = string, RawResponse = unknown, Metadata extends JsonObject = JsonObject>(options: AgentClientStreamOptions<unknown, Metadata> & {
+    events: AsyncIterable<AgentStreamEvent<Output, RawResponse>>;
+}): ClientStream<Metadata>;
+declare function customAgentEventsToClientStream<CustomEvent, Metadata extends JsonObject = JsonObject, Data extends ClientDataMap = ClientDataMap>(options: AgentClientStreamOptions<CustomEvent, Metadata, Data> & {
+    events: AsyncIterable<AgentStreamEvent<unknown, unknown> | CustomEvent>;
+    mapCustomEvent: NonNullable<AgentClientStreamOptions<CustomEvent, Metadata, Data>["mapCustomEvent"]>;
+}): ClientStream<Metadata, Data>;
+
+type CreateHttpClientTransportOptions<TRequest = ClientStreamRequest, Data extends ClientDataMap = ClientDataMap, Metadata extends JsonObject = JsonObject> = Omit<CreateFetchEventTransportOptions<TRequest, ClientStreamFrame<Metadata, Data>>, "mapEvent" | "validateResponse"> & {
+    metadataSchema?: ClientMetadataSchema<Metadata>;
+    dataSchemas?: ClientDataSchemas<Data>;
+};
+declare function createHttpClientTransport<TRequest = ClientStreamRequest, Data extends ClientDataMap = ClientDataMap, Metadata extends JsonObject = JsonObject>(options: CreateHttpClientTransportOptions<TRequest, Data, Metadata>): ClientTransport<TRequest, Data, Metadata>;
+type CreateDirectClientTransportOptions<TRequest, Data extends ClientDataMap, Metadata extends JsonObject> = {
+    handler(options: {
+        request: TRequest;
+        abortSignal?: AbortSignal;
+        headers?: HeadersInit;
+    }): ClientStream<Metadata, Data> | Promise<ClientStream<Metadata, Data>>;
+    metadataSchema?: ClientMetadataSchema<Metadata>;
+    dataSchemas?: ClientDataSchemas<Data>;
+};
+declare function createDirectClientTransport<TRequest = ClientStreamRequest, Data extends ClientDataMap = ClientDataMap, Metadata extends JsonObject = JsonObject>(options: CreateDirectClientTransportOptions<TRequest, Data, Metadata>): ClientTransport<TRequest, Data, Metadata>;
+
+declare function uiMessagesToMessages<Metadata extends JsonObject = JsonObject, Data extends ClientDataMap = ClientDataMap>(messages: readonly UIMessage<Metadata, Data>[]): Message<Metadata>[];
+declare function messagesToUIMessages<Metadata extends JsonObject = JsonObject>(messages: readonly Message<Metadata>[]): UIMessage<Metadata>[];
+declare function createClientId(prefix: string): string;
+
+declare class ClientProtocolError extends Error {
+    readonly value?: unknown | undefined;
+    constructor(message: string, value?: unknown | undefined);
+}
+declare function parseUIMessage<Metadata extends JsonObject = JsonObject, Data extends ClientDataMap = ClientDataMap>(value: unknown, options?: {
+    metadataSchema?: ClientMetadataSchema<Metadata>;
+    dataSchemas?: ClientDataSchemas<Data>;
+}): UIMessage<Metadata, Data>;
+declare function parseUIMessages<Metadata extends JsonObject = JsonObject, Data extends ClientDataMap = ClientDataMap>(value: unknown, options?: {
+    metadataSchema?: ClientMetadataSchema<Metadata>;
+    dataSchemas?: ClientDataSchemas<Data>;
+}): UIMessage<Metadata, Data>[];
+declare function parseClientStreamRequest(value: unknown): ClientStreamRequest;
+declare function parseClientStreamEvent<Metadata extends JsonObject = JsonObject, Data extends ClientDataMap = ClientDataMap>(value: unknown, options?: {
+    metadataSchema?: ClientMetadataSchema<Metadata>;
+    dataSchemas?: ClientDataSchemas<Data>;
+}): ClientStreamEvent<Metadata, Data>;
+declare function parseClientStreamFrame<Metadata extends JsonObject = JsonObject, Data extends ClientDataMap = ClientDataMap>(value: unknown, options?: {
+    metadataSchema?: ClientMetadataSchema<Metadata>;
+    dataSchemas?: ClientDataSchemas<Data>;
+}): ClientStreamFrame<Metadata, Data>;
+declare function maskedClientError(): ClientStreamError;
+declare function normalizeClientError(value: unknown): Error;
+
+declare function applyClientStreamEvent<Metadata extends JsonObject, Data extends ClientDataMap>(messages: readonly UIMessage<Metadata, Data>[], event: ClientStreamEvent<Metadata, Data>): readonly UIMessage<Metadata, Data>[];
+declare function messageText<Metadata extends JsonObject, Data extends ClientDataMap>(message: UIMessage<Metadata, Data>): string;
+declare function assistantText<Metadata extends JsonObject, Data extends ClientDataMap>(messages: readonly UIMessage<Metadata, Data>[]): string;
+
+export { type AgentClientStreamContext, type AgentClientStreamOptions, CLIENT_STREAM_PROTOCOL, type ClientCompletionRequest, type ClientDataMap, type ClientDataSchema, type ClientDataSchemas, type ClientErrorMapper, type ClientInteraction, type ClientMetadata, type ClientMetadataSchema, type ClientOutputMapper, ClientProtocolError, type ClientStream, type ClientStreamAdapterOptions, type ClientStreamCursor, type ClientStreamError, type ClientStreamEvent, type ClientStreamFrame, type ClientStreamRequest, type ClientStreamScope, type ClientTransport, type ClientTransportSendOptions, type CompletionClientStreamOptions, type CreateDirectClientTransportOptions, type CreateHttpClientTransportOptions, type CreateUIAttachment, type UIAttachment, type UIError, type UIMessage, type UIMessageGeneration, type UIMessagePart, type UIMessageRole, type UIToolMessagePart, agentToClientStream, applyClientStreamEvent, assistantText, completionToClientStream, createClientId, createDirectClientTransport, createHttpClientTransport, customAgentEventsToClientStream, maskedClientError, messageText, messagesToUIMessages, normalizeClientError, parseClientStreamEvent, parseClientStreamFrame, parseClientStreamRequest, parseUIMessage, parseUIMessages, uiMessagesToMessages };