@ag-ui/client 0.0.31 → 0.0.32

package/dist/index.d.mts

@@ -1,83 +1,55 @@
-import { ApplyEvents, BaseEvent, Message, State, RunAgentInput, RunAgent } from '@ag-ui/core';
+import { Message, State, RunAgentInput, BaseEvent, RunStartedEvent, RunFinishedEvent, RunErrorEvent, StepStartedEvent, StepFinishedEvent, TextMessageStartEvent, TextMessageContentEvent, TextMessageEndEvent, ToolCallStartEvent, ToolCallArgsEvent, ToolCallEndEvent, ToolCallResultEvent, StateSnapshotEvent, StateDeltaEvent, MessagesSnapshotEvent, RawEvent, CustomEvent, ToolCall } from '@ag-ui/core';
 export * from '@ag-ui/core';
 import { Observable } from 'rxjs';
 import { z } from 'zod';
 
-declare const defaultApplyEvents: (...args: Parameters<ApplyEvents>) => ReturnType<ApplyEvents>;
-
-declare const verifyEvents: (debug: boolean) => (source$: Observable<BaseEvent>) => Observable<BaseEvent>;
-
-declare enum HttpEventType {
-    HEADERS = "headers",
-    DATA = "data"
-}
-interface HttpDataEvent {
-    type: HttpEventType.DATA;
-    data?: Uint8Array;
+interface AgentConfig {
+    agentId?: string;
+    description?: string;
+    threadId?: string;
+    initialMessages?: Message[];
+    initialState?: State;
+    debug?: boolean;
 }
-interface HttpHeadersEvent {
-    type: HttpEventType.HEADERS;
-    status: number;
-    headers: Headers;
+interface HttpAgentConfig extends AgentConfig {
+    url: string;
+    headers?: Record<string, string>;
 }
-type HttpEvent = HttpDataEvent | HttpHeadersEvent;
-declare const runHttpRequest: (url: string, requestInit: RequestInit) => Observable<HttpEvent>;
-
-/**
- * Transforms HTTP events into BaseEvents using the appropriate format parser based on content type.
- */
-declare const transformHttpEventStream: (source$: Observable<HttpEvent>) => Observable<BaseEvent>;
-
-/**
- * Parses a stream of HTTP events into a stream of JSON objects using Server-Sent Events (SSE) format.
- * Strictly follows the SSE standard where:
- * - Events are separated by double newlines ('\n\n')
- * - Only 'data:' prefixed lines are processed
- * - Multi-line data events are supported and joined
- * - Non-data fields (event, id, retry) are ignored
- */
-declare const parseSSEStream: (source$: Observable<HttpEvent>) => Observable<any>;
-
-/**
- * Parses a stream of HTTP events into a stream of BaseEvent objects using Protocol Buffer format.
- * Each message is prefixed with a 4-byte length header (uint32 in big-endian format)
- * followed by the protocol buffer encoded message.
- */
-declare const parseProtoStream: (source$: Observable<HttpEvent>) => Observable<BaseEvent>;
+type RunAgentParameters = Partial<Pick<RunAgentInput, "runId" | "tools" | "context" | "forwardedProps">>;
 
 declare const LegacyRuntimeProtocolEvent: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
     type: z.ZodLiteral<"TextMessageStart">;
     messageId: z.ZodString;
     parentMessageId: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
-    messageId: string;
     type: "TextMessageStart";
+    messageId: string;
     parentMessageId?: string | undefined;
 }, {
-    messageId: string;
     type: "TextMessageStart";
+    messageId: string;
     parentMessageId?: string | undefined;
 }>, z.ZodObject<{
     type: z.ZodLiteral<"TextMessageContent">;
     messageId: z.ZodString;
     content: z.ZodString;
 }, "strip", z.ZodTypeAny, {
+    type: "TextMessageContent";
     messageId: string;
     content: string;
-    type: "TextMessageContent";
 }, {
+    type: "TextMessageContent";
     messageId: string;
     content: string;
-    type: "TextMessageContent";
 }>, z.ZodObject<{
     type: z.ZodLiteral<"TextMessageEnd">;
     messageId: z.ZodString;
 }, "strip", z.ZodTypeAny, {
-    messageId: string;
     type: "TextMessageEnd";
-}, {
     messageId: string;
+}, {
     type: "TextMessageEnd";
+    messageId: string;
 }>, z.ZodObject<{
     type: z.ZodLiteral<"ActionExecutionStart">;
     actionExecutionId: z.ZodString;
@@ -141,55 +113,43 @@ declare const LegacyRuntimeProtocolEvent: z.ZodDiscriminatedUnion<"type", [z.Zod
     running: z.ZodBoolean;
 }, "strip", z.ZodTypeAny, {
     role: string;
-    type: "AgentStateMessage";
+    runId: string;
     threadId: string;
+    state: string;
+    type: "AgentStateMessage";
     agentName: string;
     nodeName: string;
-    runId: string;
     active: boolean;
-    state: string;
     running: boolean;
 }, {
     role: string;
-    type: "AgentStateMessage";
+    runId: string;
     threadId: string;
+    state: string;
+    type: "AgentStateMessage";
     agentName: string;
     nodeName: string;
-    runId: string;
     active: boolean;
-    state: string;
     running: boolean;
 }>, z.ZodObject<{
     type: z.ZodLiteral<"MetaEvent">;
     name: z.ZodEnum<["LangGraphInterruptEvent", "PredictState", "Exit"]>;
     value: z.ZodAny;
 }, "strip", z.ZodTypeAny, {
-    name: "PredictState" | "LangGraphInterruptEvent" | "Exit";
     type: "MetaEvent";
+    name: "LangGraphInterruptEvent" | "PredictState" | "Exit";
     value?: any;
 }, {
-    name: "PredictState" | "LangGraphInterruptEvent" | "Exit";
     type: "MetaEvent";
+    name: "LangGraphInterruptEvent" | "PredictState" | "Exit";
     value?: any;
 }>]>;
 type LegacyRuntimeProtocolEvent = z.infer<typeof LegacyRuntimeProtocolEvent>;
 
-declare const convertToLegacyEvents: (threadId: string, runId: string, agentName: string) => (events$: Observable<BaseEvent>) => Observable<LegacyRuntimeProtocolEvent>;
-
-interface AgentConfig {
-    agentId?: string;
-    description?: string;
-    threadId?: string;
-    initialMessages?: Message[];
-    initialState?: State;
-    debug?: boolean;
-}
-interface HttpAgentConfig extends AgentConfig {
-    url: string;
-    headers?: Record<string, string>;
+interface RunAgentResult {
+    result: any;
+    newMessages: Message[];
 }
-type RunAgentParameters = Partial<Pick<RunAgentInput, "runId" | "tools" | "context" | "forwardedProps">>;
-
 declare abstract class AbstractAgent {
     agentId?: string;
     description: string;
@@ -197,19 +157,170 @@ declare abstract class AbstractAgent {
     messages: Message[];
     state: State;
     debug: boolean;
+    subscribers: AgentSubscriber[];
     constructor({ agentId, description, threadId, initialMessages, initialState, debug, }?: AgentConfig);
-    protected abstract run(...args: Parameters<RunAgent>): ReturnType<RunAgent>;
-    runAgent(parameters?: RunAgentParameters): Promise<void>;
+    subscribe(subscriber: AgentSubscriber): {
+        unsubscribe: () => void;
+    };
+    protected abstract run(input: RunAgentInput): Observable<BaseEvent>;
+    runAgent(parameters?: RunAgentParameters, subscriber?: AgentSubscriber): Promise<RunAgentResult>;
     abortRun(): void;
-    protected apply(...args: Parameters<ApplyEvents>): ReturnType<ApplyEvents>;
-    protected processApplyEvents(input: RunAgentInput, events$: ReturnType<ApplyEvents>): ReturnType<ApplyEvents>;
+    protected apply(input: RunAgentInput, events$: Observable<BaseEvent>, subscribers: AgentSubscriber[]): Observable<AgentStateMutation>;
+    protected processApplyEvents(input: RunAgentInput, events$: Observable<AgentStateMutation>, subscribers: AgentSubscriber[]): Observable<AgentStateMutation>;
     protected prepareRunAgentInput(parameters?: RunAgentParameters): RunAgentInput;
-    protected onError(error: Error): void;
-    protected onFinalize(): void;
+    protected onInitialize(input: RunAgentInput, subscribers: AgentSubscriber[]): Promise<void>;
+    protected onError(input: RunAgentInput, error: Error, subscribers: AgentSubscriber[]): Observable<AgentStateMutation>;
+    protected onFinalize(input: RunAgentInput, subscribers: AgentSubscriber[]): Promise<void>;
     clone(): any;
+    addMessage(message: Message): void;
+    addMessages(messages: Message[]): void;
+    setMessages(messages: Message[]): void;
+    setState(state: State): void;
     legacy_to_be_removed_runAgentBridged(config?: RunAgentParameters): Observable<LegacyRuntimeProtocolEvent>;
 }
 
+interface AgentStateMutation {
+    messages?: Message[];
+    state?: State;
+    stopPropagation?: boolean;
+}
+interface AgentSubscriberParams {
+    messages: Message[];
+    state: State;
+    agent: AbstractAgent;
+    input: RunAgentInput;
+}
+type MaybePromise<T> = T | Promise<T>;
+interface AgentSubscriber {
+    onRunInitialized?(params: AgentSubscriberParams): MaybePromise<Omit<AgentStateMutation, "stopPropagation"> | void>;
+    onRunFailed?(params: {
+        error: Error;
+    } & AgentSubscriberParams): MaybePromise<Omit<AgentStateMutation, "stopPropagation"> | void>;
+    onRunFinalized?(params: AgentSubscriberParams): MaybePromise<Omit<AgentStateMutation, "stopPropagation"> | void>;
+    onEvent?(params: {
+        event: BaseEvent;
+    } & AgentSubscriberParams): MaybePromise<AgentStateMutation | void>;
+    onRunStartedEvent?(params: {
+        event: RunStartedEvent;
+    } & AgentSubscriberParams): MaybePromise<AgentStateMutation | void>;
+    onRunFinishedEvent?(params: {
+        event: RunFinishedEvent;
+        result?: any;
+    } & AgentSubscriberParams): MaybePromise<AgentStateMutation | void>;
+    onRunErrorEvent?(params: {
+        event: RunErrorEvent;
+    } & AgentSubscriberParams): MaybePromise<AgentStateMutation | void>;
+    onStepStartedEvent?(params: {
+        event: StepStartedEvent;
+    } & AgentSubscriberParams): MaybePromise<AgentStateMutation | void>;
+    onStepFinishedEvent?(params: {
+        event: StepFinishedEvent;
+    } & AgentSubscriberParams): MaybePromise<AgentStateMutation | void>;
+    onTextMessageStartEvent?(params: {
+        event: TextMessageStartEvent;
+    } & AgentSubscriberParams): MaybePromise<AgentStateMutation | void>;
+    onTextMessageContentEvent?(params: {
+        event: TextMessageContentEvent;
+        textMessageBuffer: string;
+    } & AgentSubscriberParams): MaybePromise<AgentStateMutation | void>;
+    onTextMessageEndEvent?(params: {
+        event: TextMessageEndEvent;
+        textMessageBuffer: string;
+    } & AgentSubscriberParams): MaybePromise<AgentStateMutation | void>;
+    onToolCallStartEvent?(params: {
+        event: ToolCallStartEvent;
+    } & AgentSubscriberParams): MaybePromise<AgentStateMutation | void>;
+    onToolCallArgsEvent?(params: {
+        event: ToolCallArgsEvent;
+        toolCallBuffer: string;
+        toolCallName: string;
+        partialToolCallArgs: Record<string, any>;
+    } & AgentSubscriberParams): MaybePromise<AgentStateMutation | void>;
+    onToolCallEndEvent?(params: {
+        event: ToolCallEndEvent;
+        toolCallName: string;
+        toolCallArgs: Record<string, any>;
+    } & AgentSubscriberParams): MaybePromise<AgentStateMutation | void>;
+    onToolCallResultEvent?(params: {
+        event: ToolCallResultEvent;
+    } & AgentSubscriberParams): MaybePromise<AgentStateMutation | void>;
+    onStateSnapshotEvent?(params: {
+        event: StateSnapshotEvent;
+    } & AgentSubscriberParams): MaybePromise<AgentStateMutation | void>;
+    onStateDeltaEvent?(params: {
+        event: StateDeltaEvent;
+    } & AgentSubscriberParams): MaybePromise<AgentStateMutation | void>;
+    onMessagesSnapshotEvent?(params: {
+        event: MessagesSnapshotEvent;
+    } & AgentSubscriberParams): MaybePromise<AgentStateMutation | void>;
+    onRawEvent?(params: {
+        event: RawEvent;
+    } & AgentSubscriberParams): MaybePromise<AgentStateMutation | void>;
+    onCustomEvent?(params: {
+        event: CustomEvent;
+    } & AgentSubscriberParams): MaybePromise<AgentStateMutation | void>;
+    onMessagesChanged?(params: Omit<AgentSubscriberParams, "input"> & {
+        input?: RunAgentInput;
+    }): MaybePromise<void>;
+    onStateChanged?(params: Omit<AgentSubscriberParams, "input"> & {
+        input?: RunAgentInput;
+    }): MaybePromise<void>;
+    onNewMessage?(params: {
+        message: Message;
+    } & Omit<AgentSubscriberParams, "input"> & {
+        input?: RunAgentInput;
+    }): MaybePromise<void>;
+    onNewToolCall?(params: {
+        toolCall: ToolCall;
+    } & Omit<AgentSubscriberParams, "input"> & {
+        input?: RunAgentInput;
+    }): MaybePromise<void>;
+}
+
+declare const defaultApplyEvents: (input: RunAgentInput, events$: Observable<BaseEvent>, agent: AbstractAgent, subscribers: AgentSubscriber[]) => Observable<AgentStateMutation>;
+
+declare const verifyEvents: (debug: boolean) => (source$: Observable<BaseEvent>) => Observable<BaseEvent>;
+
+declare enum HttpEventType {
+    HEADERS = "headers",
+    DATA = "data"
+}
+interface HttpDataEvent {
+    type: HttpEventType.DATA;
+    data?: Uint8Array;
+}
+interface HttpHeadersEvent {
+    type: HttpEventType.HEADERS;
+    status: number;
+    headers: Headers;
+}
+type HttpEvent = HttpDataEvent | HttpHeadersEvent;
+declare const runHttpRequest: (url: string, requestInit: RequestInit) => Observable<HttpEvent>;
+
+/**
+ * Transforms HTTP events into BaseEvents using the appropriate format parser based on content type.
+ */
+declare const transformHttpEventStream: (source$: Observable<HttpEvent>) => Observable<BaseEvent>;
+
+/**
+ * Parses a stream of HTTP events into a stream of JSON objects using Server-Sent Events (SSE) format.
+ * Strictly follows the SSE standard where:
+ * - Events are separated by double newlines ('\n\n')
+ * - Only 'data:' prefixed lines are processed
+ * - Multi-line data events are supported and joined
+ * - Non-data fields (event, id, retry) are ignored
+ */
+declare const parseSSEStream: (source$: Observable<HttpEvent>) => Observable<any>;
+
+/**
+ * Parses a stream of HTTP events into a stream of BaseEvent objects using Protocol Buffer format.
+ * Each message is prefixed with a 4-byte length header (uint32 in big-endian format)
+ * followed by the protocol buffer encoded message.
+ */
+declare const parseProtoStream: (source$: Observable<HttpEvent>) => Observable<BaseEvent>;
+
+declare const convertToLegacyEvents: (threadId: string, runId: string, agentName: string) => (events$: Observable<BaseEvent>) => Observable<LegacyRuntimeProtocolEvent>;
+
 interface RunHttpAgentConfig extends RunAgentParameters {
     abortController?: AbortController;
 }
@@ -224,7 +335,7 @@ declare class HttpAgent extends AbstractAgent {
      * @returns The fetch config for the http request.
      */
     protected requestInit(input: RunAgentInput): RequestInit;
-    runAgent(parameters?: RunHttpAgentConfig): Promise<void>;
+    runAgent(parameters?: RunHttpAgentConfig): Promise<RunAgentResult>;
     abortRun(): void;
     constructor(config: HttpAgentConfig);
     run(input: RunAgentInput): Observable<BaseEvent>;