@uipath/uipath-typescript 1.0.0 → 1.1.1

package/dist/index.d.ts

@@ -56,6 +56,11 @@ interface IUiPath {
      * Get the current authentication token
      */
     getToken(): string | undefined;
+    /**
+     * Logout from the SDK, clearing all authentication state.
+     * After calling this method, the user will need to re-initialize to authenticate again.
+     */
+    logout(): void;
 }
 
 /**
@@ -116,6 +121,11 @@ declare class UiPath$1 implements IUiPath {
      * Get the current authentication token
      */
     getToken(): string | undefined;
+    /**
+     * Logout from the SDK, clearing all authentication state.
+     * After calling this method, the user will need to re-initialize to authenticate again.
+     */
+    logout(): void;
 }
 
 /**
@@ -5586,101 +5596,4430 @@ declare class UiPath extends UiPath$1 {
 }
 
 /**
- * Error thrown when authorization fails (403 errors)
- * Common scenarios:
- * - Insufficient permissions
- * - Access denied to resource
- * - Invalid scope
+ * Constants for Conversational Agent
  */
-declare class AuthorizationError extends UiPathError {
-    constructor(params?: Partial<ErrorParams>);
-}
+/**
+ * Maps API response fields to SDK field names (API → SDK)
+ * Used when transforming API responses for SDK consumers.
+ * For request transformation (SDK → API), use `transformRequest(data, ConversationMap)`.
+ */
+declare const ConversationMap: {
+    [key: string]: string;
+};
+/**
+ * Maps fields for Exchange entity to ensure consistent SDK naming
+ */
+declare const ExchangeMap: {
+    [key: string]: string;
+};
+/**
+ * Maps fields for Message entity to ensure consistent SDK naming
+ */
+declare const MessageMap: {
+    [key: string]: string;
+};
 
 /**
- * Error thrown when validation fails (400 errors or client-side validation)
- * Common scenarios:
- * - Invalid input parameters
- * - Missing required fields
- * - Invalid data format
+ * Common types for Conversational Agent
+ * Contains IDs, primitives, and utility types used across conversation types.
  */
-declare class ValidationError extends UiPathError {
-    constructor(params?: Partial<ErrorParams>);
+/**
+ * Identifies the origin of a message in the conversation.
+ */
+declare enum MessageRole {
+    System = "system",
+    User = "user",
+    Assistant = "assistant"
 }
-
 /**
- * Error thrown when a resource is not found (404 errors)
- * Common scenarios:
- * - Resource doesn't exist
- * - Invalid ID provided
- * - Resource deleted
+ * Identifies the type of an interrupt.
  */
-declare class NotFoundError extends UiPathError {
-    constructor(params?: Partial<ErrorParams>);
+declare enum InterruptType {
+    ToolCallConfirmation = "uipath_cas_tool_call_confirmation"
 }
-
 /**
- * Error thrown when rate limit is exceeded (429 errors)
- * Common scenarios:
- * - Too many requests in a time window
- * - API throttling
+ * Base interface for citation sources.
  */
-declare class RateLimitError extends UiPathError {
-    constructor(params?: Partial<ErrorParams>);
+interface CitationSourceBase {
+    /**
+     * Title for the citation source, suitable for display to users.
+     */
+    title: string;
+    /**
+     * Label number for the citation source, suitable for display to users
+     * (e.g. [1] for the first unique source, [2] for the second, etc.).
+     */
+    number: number;
 }
-
 /**
- * Error thrown when server encounters an error (5xx errors)
- * Common scenarios:
- * - Internal server error
- * - Service unavailable
- * - Gateway timeout
+ * Used when the citation can be rendered as a link.
  */
-declare class ServerError extends UiPathError {
-    constructor(params?: Partial<ErrorParams>);
+interface CitationSourceUrl extends CitationSourceBase {
     /**
-     * Checks if this is a temporary error that might succeed on retry
+     * Citation url.
      */
-    get isRetryable(): boolean;
+    url: string;
 }
-
 /**
- * Base error creation parameters - only what's needed
+ * Used when the citation references media, such as a PDF document.
  */
-interface ErrorParams {
-    message: string;
-    statusCode?: number;
-    requestId?: string;
+interface CitationSourceMedia extends CitationSourceBase {
+    /** The mime type of the media. If non-specified, should be discovered through the downloadUrl. */
+    mimeType?: string;
+    /** Download URL for the media */
+    downloadUrl?: string;
+    /** The page number for the media, if applicable (e.g. for application/pdf documents) */
+    pageNumber?: string;
+}
+/**
+ * Citation sources can target either an Url or a media (e.g. a pdf document).
+ * Repeated citation sources within a content part are identified by the same title and number.
+ */
+type CitationSource = CitationSourceUrl | CitationSourceMedia;
+/**
+ * JSON compatible primitive type.
+ */
+type JSONPrimitive = string | number | boolean | null;
+/**
+ * JSON compatible value type.
+ */
+type JSONValue = JSONPrimitive | Record<string, any> | any[];
+/**
+ * JSON compatible object type.
+ */
+type JSONObject = Record<string, JSONValue>;
+/**
+ * JSON compatible array type.
+ */
+type JSONArray = JSONValue[];
+/**
+ * An arbitrary JSON serializable object.
+ */
+type MetaData = JSONObject;
+/**
+ * Produces the provided object type with specified properties changed to optional.
+ */
+type MakeOptional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+/**
+ * Produces the provided object type with specified properties changed to required.
+ */
+type MakeRequired<T, K extends keyof T> = Omit<T, K> & Required<Pick<T, K>>;
+/**
+ * Causes typescript to simplify the display of object types created using MakeOptional, MakeRequired, and other utility
+ * types. This doesn't change the effective type, but makes popups in the ide and compile error messages cleaner.
+ */
+type Simplify<T> = T extends any[] | Date ? T : {
+    [K in keyof T]: T[K];
+} & {};
+/**
+ * Inline value - used when a value is small enough to be returned inline with an API result.
+ */
+interface InlineValue<T> {
+    inline: T;
+}
+/**
+ * External value - used when a value is too large to be returned inline with an API result.
+ */
+interface ExternalValue {
+    uri: string;
+    byteCount?: number;
 }
+/**
+ * Inline or external value - used when a value can be too large to include inline in input or output data.
+ * If the inline property is set, it contains the full value, otherwise the uri property is set and it contains an uri
+ * from which the data can be downloaded.
+ */
+type InlineOrExternalValue<T> = InlineValue<T> | ExternalValue;
+/**
+ * Tool call input value type.
+ */
+type ToolCallInputValue = JSONObject;
+/**
+ * Tool call output value type.
+ */
+type ToolCallOutputValue = JSONValue;
 
 /**
- * Base error class for all UiPath SDK errors
- * Pure TypeScript class with clean interface
+ * Core data model types for Conversational Agent REST endpoints
+ * Contains: Conversation, Exchange, Message, ContentPart, ToolCall, etc.
+ */
+
+/**
+ * Represents the order in which items should be sorted.
+ */
+declare enum SortOrder {
+    Ascending = "ascending",
+    Descending = "descending"
+}
+/**
+ * Represents a citation or reference to an external source within a content part.
  */
-declare abstract class UiPathError {
+interface Citation {
     /**
-     * Error type identifier (e.g., "AuthenticationError", "ValidationError")
+     * Unique identifier for the citation.
      */
-    readonly type: string;
+    id: string;
     /**
-     * Error message describing what went wrong
+     * Unique identifier for the citation within its content part.
      */
-    readonly message: string;
+    citationId: string;
     /**
-     * HTTP status code (400, 401, 403, 404, 500, etc.)
+     * The offset of the start of the citation target in the content part data.
      */
-    readonly statusCode?: number;
+    offset: number;
     /**
-     * Request ID for tracking with UiPath support
+     * The length of the citation target in the content part data.
      */
-    readonly requestId?: string;
+    length: number;
     /**
-     * Timestamp when the error occurred
+     * The source being referenced by this citation.
      */
-    readonly timestamp: Date;
+    sources: CitationSource[];
+    /**
+     * Timestamp indicating when the citation was created.
+     */
+    createdTime: string;
+    /**
+     * Timestamp indicating when the citation was last updated.
+     */
+    updatedTime: string;
+}
+/**
+ * Citation options for input operations (without timestamps).
+ */
+interface CitationOptions {
+    citationId: string;
+    offset: number;
+    length: number;
+    sources: CitationSource[];
+}
+/**
+ * Content part data type - can be inline or external.
+ */
+type ContentPartData = Simplify<InlineOrExternalValue<string>>;
+/**
+ * Represents a single part of message content.
+ */
+interface ContentPart {
+    /**
+     * Unique identifier for the content part.
+     */
+    id: string;
+    /**
+     * Unique identifier for the content part within the message.
+     */
+    contentPartId: string;
+    /**
+     * The MIME type of the content.
+     */
+    mimeType: string;
+    /**
+     * The actual content data.
+     */
+    data: ContentPartData;
+    /**
+     * Array of citations referenced in this content part.
+     */
+    citations: Citation[];
+    /**
+     * Indicates whether this content part is a transcript produced by the LLM.
+     */
+    isTranscript?: boolean;
+    /**
+     * Indicates whether this content part may be incomplete.
+     */
+    isIncomplete?: boolean;
+    /**
+     * Optional name for the content part.
+     */
+    name?: string;
+    /**
+     * Timestamp indicating when the content part was created.
+     */
+    createdTime: string;
+    /**
+     * Timestamp indicating when the content part was last updated.
+     */
+    updatedTime: string;
+}
+/**
+ * Represents the result of a tool call execution.
+ */
+interface ToolCallResult {
+    /**
+     * Timestamp indicating when the result was generated.
+     */
+    timestamp?: string;
+    /**
+     * The value returned by the tool.
+     */
+    output?: ToolCallOutputValue;
+    /**
+     * field for the tool call output value.
+     */
+    value?: InlineOrExternalValue<ToolCallOutputValue>;
+    /**
+     * Indicates whether the tool call resulted in an error.
+     */
+    isError?: boolean;
+    /**
+     * Indicates whether the tool call was cancelled.
+     */
+    cancelled?: boolean;
+}
+/**
+ * Represents a call to an external tool or function within a message.
+ */
+interface ToolCall {
+    /**
+     * Unique identifier for the tool call.
+     */
+    id: string;
+    /**
+     * Unique identifier for the tool call within the message.
+     */
+    toolCallId: string;
+    /**
+     * The name of the tool being called.
+     */
+    name: string;
+    /**
+     * Optional input value provided to the tool.
+     */
+    input?: ToolCallInputValue;
+    /**
+     * Legacy field for tool call input arguments.
+     */
+    arguments?: InlineOrExternalValue<ToolCallInputValue>;
+    /**
+     * Timestamp indicating when the tool call was initiated.
+     */
+    timestamp?: string;
+    /**
+     * Optional output value returned by the tool's execution.
+     */
+    result?: ToolCallResult;
+    /**
+     * Timestamp indicating when the tool call was created.
+     */
+    createdTime: string;
+    /**
+     * Timestamp indicating when the tool call was last updated.
+     */
+    updatedTime: string;
+}
+/**
+ * Represents an interrupt within a message.
+ */
+interface Interrupt {
+    /**
+     * Unique identifier for the interrupt.
+     */
+    id: string;
+    /**
+     * Unique identifier for the interrupt within the message.
+     */
+    interruptId: string;
+    /**
+     * The type of interrupt.
+     */
+    type: InterruptType;
+    /**
+     * The value associated with the interrupt start event.
+     */
+    interruptValue: unknown;
+    /**
+     * The value provided to end/resolve the interrupt.
+     */
+    endValue?: unknown;
+    /**
+     * Timestamp indicating when the interrupt was created.
+     */
+    createdTime: string;
+    /**
+     * Timestamp indicating when the interrupt was last updated.
+     */
+    updatedTime: string;
+}
+/**
+ * Represents a single message within a conversation exchange.
+ */
+interface Message {
+    /**
+     * Unique identifier for the message.
+     */
+    id: string;
+    /**
+     * Unique identifier for the message within its exchange.
+     */
+    messageId: string;
+    /**
+     * The role of the message sender.
+     */
+    role: MessageRole;
+    /**
+     * Contains the message's content parts.
+     */
+    contentParts: ContentPart[];
+    /**
+     * Array of tool calls made within this message.
+     */
+    toolCalls: ToolCall[];
+    /**
+     * Array of interrupts within this message.
+     */
+    interrupts: Interrupt[];
+    /**
+     * Timestamp indicating when the message was created.
+     */
+    createdTime: string;
+    /**
+     * Timestamp indicating when the message was last updated.
+     */
+    updatedTime: string;
+    /**
+     * Span identifier for distributed tracing.
+     */
+    spanId?: string;
+}
+/**
+ * Feedback rating type.
+ */
+declare enum FeedbackRating {
+    Positive = "positive",
+    Negative = "negative"
+}
+/**
+ * Represents a group of related messages (exchange).
+ */
+interface Exchange {
+    /**
+     * Unique identifier for the exchange.
+     */
+    id: string;
+    /**
+     * Identifies the exchange.
+     */
+    exchangeId: string;
+    /**
+     * Messages in the exchange.
+     */
+    messages: Message[];
+    /**
+     * Timestamp indicating when the exchange was created.
+     */
+    createdTime: string;
+    /**
+     * Timestamp indicating when the exchange was last updated.
+     */
+    updatedTime: string;
+    /**
+     * Span identifier for distributed tracing.
+     */
+    spanId?: string;
     /**
-     * Stack trace for debugging
+     * The optional feedback rating given by the user.
      */
-    readonly stack?: string;
+    feedbackRating?: FeedbackRating;
+}
+/**
+ * Optional configuration options for when the service automatically starts agent job(s) to serve the conversation.
+ * When not provided, service uses default configuration with RunAsMe set to false.
+ */
+interface ConversationJobStartOverrides {
+    /**
+     * Whether the job(s) should run with the user's identity (RunAsMe). Defaults to false when not provided.
+     */
+    runAsMe?: boolean;
+}
+/**
+ * Raw response type for conversation operations (without methods).
+ * Represents a conversation between users and AI agents.
+ */
+interface RawConversationGetResponse {
+    /**
+     * A globally unique identifier for the conversation.
+     */
+    id: string;
+    /**
+     * Timestamp indicating when the conversation was created.
+     */
+    createdTime: string;
+    /**
+     * Timestamp indicating when any conversation field(s) are updated.
+     */
+    updatedTime: string;
+    /**
+     * Timestamp indicating when the conversation last had activity.
+     */
+    lastActivityTime: string;
+    /**
+     * The human-readable label or title for the conversation.
+     */
+    label: string;
+    /**
+     * Whether the conversation label was automatically generated.
+     */
+    autogenerateLabel: boolean;
+    /**
+     * Identifier of the user who owns or initiated the conversation.
+     */
+    userId: string;
+    /**
+     * Identifier of the organization.
+     */
+    orgId: string;
+    /**
+     * Identifier of the tenant within the organization.
+     */
+    tenantId: string;
+    /**
+     * Identifier of the folder where the conversation is stored.
+     */
+    folderId: number;
+    /**
+     * Identifier of the agent used for this conversation
+     */
+    agentId?: number;
+    /**
+     * Trace identifier for distributed tracing.
+     */
+    traceId: string;
+    /**
+     * Span identifier for distributed tracing.
+     */
+    spanId?: string;
+    /**
+     * Optional configuration options for when the service automatically starts agent job(s).
+     */
+    jobStartOverrides?: ConversationJobStartOverrides;
+    /**
+     * Optional job key for conversations that are part of a larger job.
+     */
+    jobKey?: string;
+    /**
+     * Whether the conversation's job is running locally.
+     */
+    isLocalJobExecution?: boolean;
+}
+
+/**
+ * Event types for Conversational Agent WebSocket protocol
+ */
+
+/**
+ * Identifies how sensitive the LLM should be when detecting the start or end of speech.
+ *
+ *     * UNSPECIFIED - the default is HIGH
+ *     * HIGH - Will detect the start/end of speech more often.
+ *     * LOW - Will detect the start/end of speech less often.
+ */
+declare enum InputStreamSpeechSensitivity {
+    Unspecified = "UNSPECIFIED",
+    High = "HIGH",
+    Low = "LOW"
+}
+/**
+ * Signals that a content stream was interrupted.
+ */
+interface ContentPartInterrupted {
+}
+/**
+ * Describes the capabilities of the sender. This type allows custom properties, in addition to the ones defined.
+ */
+interface SessionCapabilities {
+    /**
+     * Indicates the sender may produce a cross exchange input stream events if the receiver indicates they can be handled.
+     */
+    asyncInputStreamEmitter?: boolean;
+    /**
+     * Indicates the sender can handle cross exchange input stream events.
+     */
+    asyncInputStreamHandler?: boolean;
+    /**
+     * Indicates the sender may produce cross exchange tool calls if the receiver indicates they can be handled.
+     */
+    asyncToolCallEmitter?: boolean;
+    /**
+     * Indicates the sender can handle cross exchange tool calls.
+     */
+    asyncToolCallHandler?: boolean;
+    /**
+     * Indicates the mime types which the sender can send in input streams and as message content, provided the receiver
+     * indicates they can handle the mime type.
+     */
+    mimeTypesEmitted?: string[];
+    /**
+     * Indicates the mime types the sender can handle. Wildcards such as "*\/*" and "text/*" are allowed.
+     */
+    mimeTypesHandled?: string[];
+    /** Allow custom properties */
+    [key: string]: unknown;
+}
+/**
+ * Signals the start of a session.
+ */
+interface SessionStartEvent {
+    /**
+     * Indicates the capabilities of the end point that sent the session start event.
+     */
+    capabilities?: SessionCapabilities;
+    /**
+     * Optional metadata that can be used for any data pertaining to the starting event stream.
+     */
+    metaData?: MetaData;
+}
+/**
+ * Signals the acceptance of the start of a session.
+ */
+interface SessionStartedEvent {
+    /**
+     * Indicates the capabilities of the end point that received the session start event.
+     */
+    capabilities?: SessionCapabilities;
+}
+/**
+ * Indicates the end of a session.
+ */
+interface SessionEndEvent {
+    /**
+     * Optional metadata that can be used for any data having to do with the completion of the session.
+     */
+    metaData?: MetaData;
+}
+/**
+ * Indicates the service wants the client to end the current session.
+ */
+interface SessionEndingEvent {
+    /**
+     * Number of milliseconds before the websocket is closed by the service to force the session to end.
+     */
+    timeToLiveMS: number;
+}
+/**
+ * Signals the start of an exchange of messages within a conversation.
+ */
+interface ExchangeStartEvent {
+    /**
+     * Optional value specifying the sequence number of the exchange within the conversation.
+     */
+    conversationSequence?: number;
+    /**
+     * Optional metadata that can be used for any data pertaining to the starting event stream.
+     */
+    metadata?: MetaData;
+    /**
+     * The time the exchange started.
+     */
+    timestamp?: string;
+}
+/**
+ * Signals the end of an exchange of messages within a conversation.
+ */
+interface ExchangeEndEvent {
+    /**
+     * Optional metadata that can be used for any data having to do with the completion of the event stream.
+     */
+    metaData?: MetaData;
+}
+/**
+ * Signals the start of a message.
+ */
+interface MessageStartEvent {
+    /**
+     * Optional value that provides the sequence of the message within the exchange.
+     */
+    exchangeSequence?: number;
+    /**
+     * Message timestamp.
+     */
+    timestamp?: string;
+    /**
+     * Required value that identifies the origin of the message (system, user, or agent).
+     */
+    role: MessageRole;
+    /**
+     * Optional metadata that can be used for any data pertaining to the starting event stream.
+     */
+    metaData?: MetaData;
+}
+/**
+ * Signals the end of a message.
+ */
+interface MessageEndEvent {
+    /**
+     * Optional metadata that can be used for any data having to do with the completion of the event stream.
+     */
+    metaData?: MetaData;
+}
+/**
+ * Content part start event metadata with transcript indicator.
+ */
+type ContentPartStartMetaData = MetaData & {
+    /**
+     * Indicates that the content part is transcript produced by the LLM from user voice input.
+     */
+    isTranscript?: boolean;
+};
+/**
+ * Signals the start of a message content part.
+ */
+interface ContentPartStartEvent {
+    /**
+     * Describes the type and format of a content part.
+     */
+    mimeType: string;
+    /**
+     * Optional metadata that can be used for any data pertaining to the starting event stream.
+     */
+    metaData?: ContentPartStartMetaData;
+    /**
+     * If present, indicates that the content part's data is stored externally.
+     */
+    externalValue?: ExternalValue;
+    /**
+     * Optional name for the content part. Typically used for file attachment names.
+     */
+    name?: string;
+    /**
+     * The time the content part was created.
+     */
+    timestamp?: string;
+}
+/**
+ * Signals the end of a message content part.
+ */
+interface ContentPartEndEvent {
+    /**
+     * Optional value that provides the contentPartSequence sent in the last content part chunk sent.
+     */
+    lastChunkContentPartSequence?: number;
+    /**
+     * Indicates if the content part stream was interrupted.
+     */
+    interrupted?: ContentPartInterrupted;
+    /**
+     * Optional metadata that can be used for any data having to do with the completion of the event stream.
+     */
+    metaData?: MetaData;
+}
+/**
+ * Represents the start of an error condition.
+ */
+interface ErrorStartEvent {
+    /**
+     * A message that can be displayed to the user.
+     */
+    message: string;
+    /**
+     * An optional property that contains error related details.
+     */
+    details?: JSONValue;
+}
+/**
+ * Represents the end of an error condition.
+ */
+interface ErrorEndEvent {
+}
+/**
+ * Encapsulates sub-events that represent the start and end of an error condition.
+ */
+interface ErrorEvent {
+    /**
+     * An identifier for the error.
+     */
+    errorId: string;
+    /**
+     * If present, indicates the start of an error condition.
+     */
+    startError?: ErrorStartEvent;
+    /**
+     * If present, indicates the end of an error condition.
+     */
+    endError?: ErrorEndEvent;
+}
+/**
+ * Indicates the start of a citation target in the stream of content part chunks.
+ */
+interface CitationStartEvent {
+}
+/**
+ * Indicates the end of a citation target in the stream of content part chunks.
+ */
+interface CitationEndEvent {
+    /**
+     * Provides data concerning the citation sources.
+     */
+    sources: CitationSource[];
+}
+/**
+ * Encapsulates sub-events related to citations.
+ */
+interface CitationEvent {
+    /**
+     * Identifies a set of citation sources.
+     */
+    citationId: string;
+    /**
+     * Indicates the start of a citation target.
+     */
+    startCitation?: CitationStartEvent;
+    /**
+     * Indicates the end of a citation target.
+     */
+    endCitation?: CitationEndEvent;
+    /**
+     * Sent by the service to indicate an error condition impacting a citation.
+     */
+    citationError?: ErrorEvent;
+}
+/**
+ * Contains a chunk of a message content part.
+ */
+interface ContentPartChunkEvent {
+    /**
+     * Content part data.
+     */
+    data?: string;
+    /**
+     * Sub-event for attaching citations to content chunks.
+     */
+    citation?: CitationEvent;
+}
+/**
+ * Signals the start of an input stream.
+ */
+interface AsyncInputStreamStartEvent {
+    /**
+     * Describes the type of data sent over the input stream.
+     */
+    mimeType: string;
+    /**
+     * Determines how sensitive the LLM should be in detecting the start of speech.
+     */
+    startOfSpeechSensitivity?: InputStreamSpeechSensitivity;
+    /**
+     * Determines how sensitive the LLM should be in detecting the end of speech.
+     */
+    endOfSpeechSensitivity?: InputStreamSpeechSensitivity;
+    /**
+     * The required duration of detected speech before start-of-speech is committed.
+     */
+    prefixPaddingMs?: number;
+    /**
+     * The required duration of detected non-speech before end-of-speech is committed.
+     */
+    silenceDurationMs?: number;
+    /**
+     * Optional metadata that can be used for any data pertaining to the starting event stream.
+     */
+    metaData?: MetaData;
+}
+/**
+ * Signals the end of a cross exchange input stream.
+ */
+interface AsyncInputStreamEndEvent {
+    /**
+     * Optional metadata that can be used for any data having to do with the completion of the event stream.
+     */
+    metaData?: MetaData;
+    /**
+     * Optional value that provides the contentPartSequence value in the last content part chunk sent.
+     */
+    lastChunkContentPartSequence?: number;
+}
+/**
+ * Async input stream chunk event.
+ */
+interface AsyncInputStreamChunkEvent {
+    data: string;
+}
+/**
+ * Signals the start of a tool call.
+ */
+interface ToolCallStartEvent {
+    /**
+     * Identifies the tool that is to be called.
+     */
+    toolName: string;
+    /**
+     * The time the tool call was made.
+     */
+    timestamp?: string;
+    /**
+     * Optional input value provided to the tool when executed.
+     */
+    input?: ToolCallInputValue;
+    /**
+     * Optional metadata pertaining to the tool call.
+     */
+    metaData?: MetaData;
+}
+/**
+ * Signals the end of a tool call.
+ */
+interface ToolCallEndEvent {
+    /**
+     * The time the result was generated.
+     */
+    timestamp?: string;
+    /**
+     * Optional output value returned by the tool's execution.
+     */
+    output?: ToolCallOutputValue;
+    /**
+     * Indicates if the tool call resulted in an error.
+     */
+    isError?: boolean;
+    /**
+     * Indicates if the tool call was canceled before the result was generated.
+     */
+    cancelled?: boolean;
+    /**
+     * Metadata pertaining to the tool call's execution or result.
+     */
+    metaData?: MetaData;
+}
+/**
+ * Allows additional events to be sent in the context of the enclosing event stream.
+ */
+interface MetaEvent {
+    [key: string]: unknown;
+}
+/**
+ * Indicates the update of the conversation label.
+ */
+interface LabelUpdatedEvent {
+    /**
+     * The new label for the conversation.
+     */
+    label: string;
+    /**
+     * Whether the label was autogenerated by the system, or manually updated through the API.
+     */
+    autogenerated: boolean;
+}
+/**
+ * Encapsulates the data related to a tool call event.
+ */
+interface ToolCallEvent {
+    /**
+     * Identifies the tool call.
+     */
+    toolCallId: string;
+    /**
+     * Signals the start of a tool call.
+     */
+    startToolCall?: ToolCallStartEvent;
+    /**
+     * Signals the end of a tool call.
+     */
+    endToolCall?: ToolCallEndEvent;
+    /**
+     * Allows additional events to be sent in the context of the enclosing event stream.
+     */
+    metaEvent?: MetaEvent;
+    /**
+     * Sent by the service to indicate an error condition impacting a tool call.
+     */
+    toolCallError?: ErrorEvent;
+}
+/**
+ * Schema for tool call confirmation interrupt value.
+ */
+interface ToolCallConfirmationValue {
+    /**
+     * The ID of the tool call being confirmed.
+     */
+    toolCallId: string;
+    /**
+     * The name of the tool to be called.
+     */
+    toolName: string;
+    /**
+     * The input schema for the tool call.
+     */
+    inputSchema: JSONValue;
+    /**
+     * The input value for the tool call.
+     */
+    inputValue?: JSONValue;
+}
+/**
+ * Schema for tool call confirmation end value.
+ */
+interface ToolCallConfirmationEndValue {
+    /**
+     * Whether the tool call was approved.
+     */
+    approved: boolean;
+    /**
+     * Modified input parameters for the tool call.
+     */
+    input?: JSONValue;
+}
+/**
+ * Known interrupt start event for tool call confirmation.
+ */
+interface ToolCallConfirmationInterruptStartEvent {
+    /**
+     * Tool call confirmation interrupt type.
+     */
+    type: typeof InterruptType.ToolCallConfirmation;
+    /**
+     * The tool call confirmation data.
+     */
+    value: ToolCallConfirmationValue;
+}
+/**
+ * Generic interrupt start event for custom interrupts.
+ */
+interface GenericInterruptStartEvent {
+    /**
+     * The type of the interrupt.
+     */
+    type: string;
+    /**
+     * The value of the interrupt.
+     */
+    value: unknown;
+}
+/**
+ * Signals the start of an interrupt - a pause point where the agent needs external input.
+ */
+type InterruptStartEvent = ToolCallConfirmationInterruptStartEvent | GenericInterruptStartEvent;
+/**
+ * Signals the interrupt end event with the provided value.
+ */
+type InterruptEndEvent = Record<string, unknown>;
+/**
+ * Encapsulates interrupt-related events within a message.
+ */
+interface InterruptEvent {
+    /**
+     * Identifies the interrupt.
+     */
+    interruptId: string;
+    /**
+     * Signals the start of an interrupt.
+     */
+    startInterrupt?: InterruptStartEvent;
+    /**
+     * Signals the end of an interrupt.
+     */
+    endInterrupt?: InterruptEndEvent;
+}
+/**
+ * Encapsulates sub-events related to message content parts.
+ */
+interface ContentPartEvent {
+    /**
+     * Identifies the content part.
+     */
+    contentPartId: string;
+    /**
+     * Optional value that signals the start of message content.
+     */
+    startContentPart?: ContentPartStartEvent;
+    /**
+     * Optional value that signals the end of message content.
+     */
+    endContentPart?: ContentPartEndEvent;
+    /**
+     * Optional content part chunk sub-event.
+     */
+    chunk?: ContentPartChunkEvent;
+    /**
+     * Allows additional events to be sent in the context of the enclosing event stream.
+     */
+    metaEvent?: MetaEvent;
+    /**
+     * Sent by the service to indicate an error condition impacting a content part.
+     */
+    contentPartError?: ErrorEvent;
+}
+/**
+ * Encapsulates sub-events related to a message within an exchange.
+ */
+interface MessageEvent {
+    /**
+     * Identifies a message.
+     */
+    messageId: string;
+    /**
+     * Optional value that signals that start of a message.
+     */
+    startMessage?: MessageStartEvent;
+    /**
+     * Optional value that signals the end of a message.
+     */
+    endMessage?: MessageEndEvent;
+    /**
+     * Optional content part sub-event.
+     */
+    contentPart?: ContentPartEvent;
+    /**
+     * Optional tool call sub-event.
+     */
+    toolCall?: ToolCallEvent;
+    /**
+     * Optional interrupt sub-event for human-in-the-loop patterns.
+     */
+    interrupt?: InterruptEvent;
+    /**
+     * Allows additional events to be sent in the context of the enclosing event stream.
+     */
+    metaEvent?: MetaEvent;
+    /**
+     * Sent by the service to indicate an error condition impacting a message.
+     */
+    messageError?: ErrorEvent;
+}
+/**
+ * Encapsulates events related to a cross exchange input stream for the conversation.
+ */
+interface AsyncInputStreamEvent {
+    /**
+     * Identifies the input stream.
+     */
+    streamId: string;
+    /**
+     * Optional value that signals the start of an input stream.
+     */
+    startAsyncInputStream?: AsyncInputStreamStartEvent;
+    /**
+     * Optional value that signals the end of an input stream.
+     */
+    endAsyncInputStream?: AsyncInputStreamEndEvent;
+    /**
+     * Optional input stream chunk sub-event.
+     */
+    chunk?: AsyncInputStreamChunkEvent;
+    /**
+     * Allows additional events to be sent in the context of the enclosing event stream.
+     */
+    metaEvent?: MetaEvent;
+    /**
+     * Sent by the service to indicate an error condition impacting an async input stream.
+     */
+    asyncInputStreamError?: ErrorEvent;
+}
+/**
+ * An event that applies to a single exchange of messages within a conversation.
+ */
+interface ExchangeEvent {
+    /**
+     * Identifies the exchange.
+     */
+    exchangeId: string;
+    /**
+     * Optional value that signals the start of an exchange.
+     */
+    startExchange?: ExchangeStartEvent;
+    /**
+     * Optional value that signals the end of an exchange.
+     */
+    endExchange?: ExchangeEndEvent;
+    /**
+     * Optional message sub-events related to the exchange.
+     */
+    message?: MessageEvent;
+    /**
+     * Allows additional events to be sent in the context of the enclosing event stream.
+     */
+    metaEvent?: MetaEvent;
+    /**
+     * Sent by the service to indicate an error condition impacting an exchange.
+     */
+    exchangeError?: ErrorEvent;
+}
+/**
+ * The ConversationEvent type represents an event in a conversation with an LLM.
+ */
+interface ConversationEvent {
+    /**
+     * A globally unique identifier for conversation to which the other sub-event and data properties apply.
+     */
+    conversationId: string;
+    /**
+     * Signals the start of session for a conversation.
+     */
+    startSession?: SessionStartEvent;
+    /**
+     * Sent in response to a SessionStartEvent to signal the acceptance of the session.
+     */
+    sessionStarted?: SessionStartedEvent;
+    /**
+     * Sent by the service when the client needs to end the current session.
+     */
+    sessionEnding?: SessionEndingEvent;
+    /**
+     * Signals the end of a session for a conversation.
+     */
+    endSession?: SessionEndEvent;
+    /**
+     * Optional exchange sub-event.
+     */
+    exchange?: ExchangeEvent;
+    /**
+     * Optional input stream sub-events.
+     */
+    asyncInputStream?: AsyncInputStreamEvent;
+    /**
+     * Optional async tool call sub-event.
+     */
+    asyncToolCall?: ToolCallEvent;
+    /**
+     * Indicates that the conversation's label has been updated.
+     */
+    labelUpdated?: LabelUpdatedEvent;
+    /**
+     * Allows additional events to be sent in the context of the enclosing event stream.
+     */
+    metaEvent?: MetaEvent;
+    /**
+     * Sent by the service to indicate an error condition impacting a conversation.
+     */
+    conversationError?: ErrorEvent;
+}
+
+/**
+ * Content Part Stream Types
+ *
+ * Defines the public API for interacting with streaming content parts
+ * within a message. Content parts represent text, audio, images, etc.
+ */
+
+/**
+ * Error encountered during citation processing
+ */
+type CitationError = {
+    citationId: string;
+    errorType: CitationErrorType;
+};
+/**
+ * Types of citation processing errors
+ */
+declare enum CitationErrorType {
+    CitationNotEnded = "CitationNotEnded",
+    CitationNotStarted = "CitationNotStarted"
+}
+/**
+ * Aggregated data for a completed content part
+ *
+ * Contains the full buffered text, citations, and metadata
+ * available after a content part stream has ended.
+ */
+type CompletedContentPart = ContentPartStartEvent & ContentPartEndEvent & {
+    contentPartId: string;
+    data: string;
+    citations: CitationOptions[];
+    citationErrors: CitationError[];
+};
+/**
+ * Model for content part event helpers.
+ *
+ * A content part is a single piece of content within a message — text,
+ * audio, an image, or a transcript. Use the type-check properties
+ * (`isText`, `isMarkdown`, `isHtml`, `isAudio`, `isImage`, `isTranscript`)
+ * to determine the content type and handle it accordingly.
+ *
+ * @example Streaming markdown content
+ * ```typescript
+ * message.onContentPartStart((part) => {
+ *   if (part.isMarkdown) {
+ *     part.onChunk((chunk) => {
+ *       process.stdout.write(chunk.data ?? '');
+ *     });
+ *   }
+ * });
+ * ```
+ *
+ * @example Handling different content types
+ * ```typescript
+ * message.onContentPartStart((part) => {
+ *   if (part.isText) {
+ *     part.onChunk((chunk) => showPlainText(chunk.data ?? ''));
+ *   } else if (part.isMarkdown) {
+ *     part.onChunk((chunk) => renderMarkdown(chunk.data ?? ''));
+ *   } else if (part.isHtml) {
+ *     part.onChunk((chunk) => renderHtml(chunk.data ?? ''));
+ *   } else if (part.isAudio) {
+ *     part.onChunk((chunk) => audioPlayer.enqueue(chunk.data ?? ''));
+ *   } else if (part.isImage) {
+ *     part.onChunk((chunk) => imageBuffer.append(chunk.data ?? ''));
+ *   } else if (part.isTranscript) {
+ *     part.onChunk((chunk) => showTranscript(chunk.data ?? ''));
+ *   }
+ * });
+ * ```
+ *
+ * @example Getting complete content with citations (buffered)
+ * ```typescript
+ * message.onContentPartStart((part) => {
+ *   part.onCompleted((completed) => {
+ *     console.log(`Full text: ${completed.data}`);
+ *
+ *     // Access citations — each has offset, length, and sources
+ *     for (const citation of completed.citations) {
+ *       const citedText = completed.data.substring(
+ *         citation.offset,
+ *         citation.offset + citation.length
+ *       );
+ *       console.log(`"${citedText}" cited from:`, citation.sources);
+ *     }
+ *   });
+ * });
+ * ```
+ *
+ * @example Using the content part completed handler at the message level
+ * ```typescript
+ * message.onContentPartCompleted((completed) => {
+ *   console.log(`[${completed.mimeType}] ${completed.data}`);
+ * });
+ * ```
+ */
+interface ContentPartStream {
+    /** Unique identifier for this content part */
+    readonly contentPartId: string;
+    /** The MIME type of this content part, or undefined if start event not yet received */
+    readonly mimeType: string | undefined;
+    /** Whether this content part is plain text. Matches `text/plain`. */
+    readonly isText: boolean;
+    /** Whether this content part is markdown. Matches `text/markdown`. */
+    readonly isMarkdown: boolean;
+    /** Whether this content part is HTML. Matches `text/html`. */
+    readonly isHtml: boolean;
+    /** Whether this content part is audio content */
+    readonly isAudio: boolean;
+    /** Whether this content part is an image */
+    readonly isImage: boolean;
+    /** Whether this content part is a transcript (from speech-to-text) */
+    readonly isTranscript: boolean;
+    /**
+     * The start event, or undefined if not yet received
+     * @internal
+     */
+    readonly startEventMaybe: ContentPartStartEvent | undefined;
+    /**
+     * The start event (throws if not yet received)
+     * @internal
+     */
+    readonly startEvent: MakeRequired<ContentPartStartEvent, 'timestamp'>;
+    /** Whether this content part has ended */
+    readonly ended: boolean;
+    /**
+     * Registers a handler for error start events
+     *
+     * @param cb - Callback receiving the error event
+     * @returns Cleanup function to remove the handler
+     *
+     * @example Content part error handling
+     * ```typescript
+     * part.onErrorStart((error) => {
+     *   console.error(`Content part error: ${error.message}`);
+     * });
+     * ```
+     */
+    onErrorStart(cb: (error: {
+        errorId: string;
+    } & ErrorStartEvent) => void): () => void;
+    /**
+     * Registers a handler for error end events
+     * @param cb - Callback receiving the error end event
+     * @returns Cleanup function to remove the handler
+     */
+    onErrorEnd(cb: (error: {
+        errorId: string;
+    } & ErrorEndEvent) => void): () => void;
+    /**
+     * Registers a handler for content part chunks
+     *
+     * Chunks are the fundamental unit of streaming data. Each chunk
+     * contains a piece of the content (text, audio data, etc.).
+     *
+     * @param cb - Callback receiving each chunk
+     * @returns Cleanup function to remove the handler
+     *
+     * @example Streaming text output
+     * ```typescript
+     * part.onChunk((chunk) => {
+     *   process.stdout.write(chunk.data ?? '');
+     * });
+     * ```
+     */
+    onChunk(cb: (chunk: ContentPartChunkEvent) => void): () => void;
+    /**
+     * Registers a handler for content part end events
+     *
+     * @param cb - Callback receiving the end event
+     * @returns Cleanup function to remove the handler
+     *
+     * @example Tracking content part lifecycle
+     * ```typescript
+     * part.onContentPartEnd((endEvent) => {
+     *   console.log('Content part finished');
+     * });
+     * ```
+     */
+    onContentPartEnd(cb: (endContentPart: ContentPartEndEvent) => void): () => void;
+    /**
+     * Registers a handler called when this content part finishes
+     *
+     * The handler receives the aggregated content part data including
+     * all buffered text, citations, and any citation errors.
+     *
+     * @param cb - Callback receiving the completed content part data
+     *
+     * @example Getting buffered content with citation data
+     * ```typescript
+     * part.onCompleted((completed) => {
+     *   console.log(`Content type: ${completed.mimeType}`);
+     *   console.log(`Full text: ${completed.data}`);
+     *
+     *   // Citations provide offset/length into the text and source references
+     *   for (const citation of completed.citations) {
+     *     const citedText = completed.data.substring(
+     *       citation.offset,
+     *       citation.offset + citation.length
+     *     );
+     *     console.log(`"${citedText}" — sources:`, citation.sources);
+     *   }
+     *
+     *   // Citation errors indicate malformed citation ranges
+     *   if (completed.citationErrors.length > 0) {
+     *     console.warn('Citation errors:', completed.citationErrors);
+     *   }
+     * });
+     * ```
+     */
+    onCompleted(cb: (completedContentPart: CompletedContentPart) => void): void;
+    /**
+     * Sends a content part chunk
+     *
+     * @param chunk - Chunk data to send
+     *
+     * @example Sending text chunks
+     * ```typescript
+     * part.sendChunk({ data: 'Hello ' });
+     * part.sendChunk({ data: 'world!' });
+     * ```
+     */
+    sendChunk(chunk: ContentPartChunkEvent): void;
+    /**
+     * Ends the content part stream
+     *
+     * @param endContentPart - Optional end event data
+     *
+     * @example Ending a content part
+     * ```typescript
+     * part.sendContentPartEnd();
+     * ```
+     */
+    sendContentPartEnd(endContentPart?: ContentPartEndEvent): void;
+    /**
+     * Sends an error start event for this content part
+     * @param args - Error details including optional error ID and message
+     * @internal
+     */
+    sendErrorStart(args: {
+        errorId?: string;
+    } & ErrorStartEvent): void;
+    /**
+     * Sends an error end event for this content part
+     * @param args - Error end details including the error ID
+     * @internal
+     */
+    sendErrorEnd(args: {
+        errorId: string;
+    } & ErrorEndEvent): void;
+    /**
+     * Sends a metadata event for this content part
+     * @param metaEvent - Metadata to send
+     * @internal
+     */
+    sendMetaEvent(metaEvent: MetaEvent): void;
+    /**
+     * Sends a chunk that starts a citation range
+     *
+     * Marks the beginning of a cited passage. All subsequent chunks
+     * until `sendChunkWithCitationEnd` are considered part of this citation.
+     *
+     * @param chunk - Chunk data with citation ID
+     * @internal
+     */
+    sendChunkWithCitationStart(chunk: Omit<ContentPartChunkEvent, 'citation'> & {
+        citationId: string;
+    }): void;
+    /**
+     * Sends a chunk that ends a citation range
+     *
+     * Marks the end of a cited passage and provides the citation sources.
+     *
+     * @param chunk - Chunk data with citation ID and sources
+     * @internal
+     */
+    sendChunkWithCitationEnd(chunk: Omit<ContentPartChunkEvent, 'citation'> & {
+        citationId: string;
+        sources: CitationSource[];
+    }): void;
+    /**
+     * Sends a chunk that is a complete citation (start and end in one)
+     *
+     * Use this for inline citations where the entire cited text is in a single chunk.
+     *
+     * @param chunk - Chunk data with citation ID and sources
+     * @internal
+     */
+    sendChunkWithCitation(chunk: Omit<ContentPartChunkEvent, 'citation'> & {
+        citationId: string;
+        sources: CitationSource[];
+    }): void;
+    /**
+     * Emits a raw content part event
+     * @param contentPartEvent - The event to emit (contentPartId is added automatically)
+     * @internal
+     */
+    emit(contentPartEvent: Omit<ContentPartEvent, 'contentPartId'>): void;
+    /**
+     * Returns a string representation of this content part
+     * @internal
+     */
+    toString(): string;
+}
+
+/**
+ * Consumer-facing interface for ToolCallEventHelper
+ *
+ * Defines the public API for interacting with tool call events
+ * within a message. Tool calls represent external tool invocations
+ * made by the assistant during a conversation.
+ */
+
+/**
+ * Aggregated data for a completed tool call
+ *
+ * Contains the merged start and end event data
+ * available after a tool call has ended.
+ */
+type CompletedToolCall = ToolCallStartEvent & ToolCallEndEvent & {
+    toolCallId: string;
+};
+/**
+ * Consumer-facing model for tool call event helpers.
+ *
+ * A tool call represents the agent invoking an external tool (API call,
+ * database query, etc.) during a conversation. Tool calls live within
+ * a message and have a start event (with tool name and input) and an
+ * end event (with the output/result).
+ *
+ * @example Listening for tool call results
+ * ```typescript
+ * message.onToolCallStart((toolCall) => {
+ *   console.log(`Tool: ${toolCall.startEvent.toolName}`);
+ *   toolCall.onToolCallEnd((endEvent) => {
+ *     console.log('Tool call completed:', endEvent.output);
+ *   });
+ * });
+ * ```
+ *
+ * @example Parsing tool call input and output
+ * ```typescript
+ * message.onToolCallStart((toolCall) => {
+ *   const { toolName, input } = toolCall.startEvent;
+ *   const parsedInput = JSON.parse(input ?? '{}');
+ *   console.log(`Calling ${toolName} with:`, parsedInput);
+ *
+ *   toolCall.onToolCallEnd((endEvent) => {
+ *     const result = JSON.parse(endEvent.output ?? '{}');
+ *     console.log(`${toolName} returned:`, result);
+ *   });
+ * });
+ * ```
+ *
+ * @example Responding to a tool call (agent-side)
+ * ```typescript
+ * message.onToolCallStart(async (toolCall) => {
+ *   const { toolName, input } = toolCall.startEvent;
+ *
+ *   // Execute the tool and return the result
+ *   const result = await executeTool(toolName, input);
+ *   toolCall.sendToolCallEnd({
+ *     output: JSON.stringify(result)
+ *   });
+ * });
+ * ```
+ */
+interface ToolCallStream {
+    /** Unique identifier for this tool call */
+    readonly toolCallId: string;
+    /**
+     * The start event, or undefined if not yet received
+     * @internal
+     */
+    readonly startEventMaybe: ToolCallStartEvent | undefined;
+    /**
+     * The start event (throws if not yet received)
+     * @internal
+     */
+    readonly startEvent: MakeRequired<ToolCallStartEvent, 'timestamp'>;
+    /** Whether this tool call has ended */
+    readonly ended: boolean;
+    /**
+     * Registers a handler for error start events
+     *
+     * @param cb - Callback receiving the error event
+     * @returns Cleanup function to remove the handler
+     *
+     * @example Tool call error handling
+     * ```typescript
+     * toolCall.onErrorStart((error) => {
+     *   console.error(`Tool call error: ${error.message}`);
+     * });
+     * ```
+     */
+    onErrorStart(cb: (error: {
+        errorId: string;
+    } & ErrorStartEvent) => void): () => void;
+    /**
+     * Registers a handler for error end events
+     * @param cb - Callback receiving the error end event
+     * @returns Cleanup function to remove the handler
+     */
+    onErrorEnd(cb: (error: {
+        errorId: string;
+    } & ErrorEndEvent) => void): () => void;
+    /**
+     * Registers a handler for tool call end events
+     *
+     * @param cb - Callback receiving the end event
+     * @returns Cleanup function to remove the handler
+     *
+     * @example Handling tool call completion
+     * ```typescript
+     * toolCall.onToolCallEnd((endEvent) => {
+     *   console.log('Output:', endEvent.output);
+     * });
+     * ```
+     */
+    onToolCallEnd(cb: (endToolCall: ToolCallEndEvent) => void): () => void;
+    /**
+     * Ends the tool call
+     *
+     * @param endToolCall - Optional end event data
+     *
+     * @example Completing a tool call with output
+     * ```typescript
+     * toolCall.sendToolCallEnd({
+     *   output: JSON.stringify({ temperature: 18, condition: 'cloudy' })
+     * });
+     * ```
+     */
+    sendToolCallEnd(endToolCall?: ToolCallEndEvent): void;
+    /**
+     * Sends an error start event for this tool call
+     * @param args - Error details including optional error ID and message
+     * @internal
+     */
+    sendErrorStart(args: {
+        errorId?: string;
+    } & ErrorStartEvent): void;
+    /**
+     * Sends an error end event for this tool call
+     * @param args - Error end details including the error ID
+     * @internal
+     */
+    sendErrorEnd(args: {
+        errorId: string;
+    } & ErrorEndEvent): void;
+    /**
+     * Sends a metadata event for this tool call
+     * @param metaEvent - Metadata to send
+     * @internal
+     */
+    sendMetaEvent(metaEvent: MetaEvent): void;
+    /**
+     * Emits a raw tool call event
+     * @param toolCallEvent - The event to emit (toolCallId is added automatically)
+     * @internal
+     */
+    emit(toolCallEvent: Omit<ToolCallEvent, 'toolCallId'>): void;
+    /**
+     * Returns a string representation of this tool call
+     * @internal
+     */
+    toString(): string;
+}
+/**
+ * Consumer-facing model for async tool call event helpers.
+ *
+ * Async tool calls operate at the session level (not within a single message)
+ * and can span across multiple exchanges. They are used for long-running
+ * tool invocations that need to persist beyond a single request-response cycle.
+ *
+ * Unlike regular {@link ToolCallStream} which live inside a message,
+ * async tool calls are managed directly on the {@link SessionStream}.
+ *
+ * @example Listening for async tool call completion
+ * ```typescript
+ * session.onAsyncToolCallStart((toolCall) => {
+ *   console.log(`Async tool started: ${toolCall.startEvent.toolName}`);
+ *   toolCall.onToolCallEnd((endEvent) => {
+ *     console.log('Async tool completed:', endEvent.output);
+ *   });
+ * });
+ * ```
+ *
+ * @example Starting and completing an async tool call
+ * ```typescript
+ * // Start a long-running analysis
+ * const toolCall = session.startAsyncToolCall({
+ *   toolName: 'document-analysis',
+ *   input: JSON.stringify({ documentId: 'doc-123' })
+ * });
+ *
+ * // ... perform the analysis across multiple exchanges ...
+ *
+ * // Complete when done
+ * toolCall.sendToolCallEnd({
+ *   output: JSON.stringify({ summary: 'Analysis complete', pages: 42 })
+ * });
+ * ```
+ *
+ * @example Handling errors on async tool calls
+ * ```typescript
+ * session.onAsyncToolCallStart((toolCall) => {
+ *   toolCall.onErrorStart((error) => {
+ *     console.error(`Async tool error: ${error.message}`);
+ *   });
+ * });
+ * ```
+ */
+interface AsyncToolCallStream {
+    /** Unique identifier for this async tool call */
+    readonly toolCallId: string;
+    /**
+     * The start event, or undefined if not yet received
+     * @internal
+     */
+    readonly startEventMaybe: ToolCallStartEvent | undefined;
+    /**
+     * The start event (throws if not yet received)
+     * @internal
+     */
+    readonly startEvent: MakeRequired<ToolCallStartEvent, 'timestamp'>;
+    /** Whether this async tool call has ended */
+    readonly ended: boolean;
+    /**
+     * Registers a handler for error start events
+     * @param cb - Callback receiving the error event
+     * @returns Cleanup function to remove the handler
+     */
+    onErrorStart(cb: (error: {
+        errorId: string;
+    } & ErrorStartEvent) => void): () => void;
+    /**
+     * Registers a handler for error end events
+     * @param cb - Callback receiving the error end event
+     * @returns Cleanup function to remove the handler
+     */
+    onErrorEnd(cb: (error: {
+        errorId: string;
+    } & ErrorEndEvent) => void): () => void;
+    /**
+     * Registers a handler for tool call end events
+     * @param cb - Callback receiving the end event
+     * @returns Cleanup function to remove the handler
+     */
+    onToolCallEnd(cb: (endToolCall: ToolCallEndEvent) => void): () => void;
+    /**
+     * Ends the async tool call
+     * @param endToolCall - Optional end event data including output
+     */
+    sendToolCallEnd(endToolCall?: ToolCallEndEvent): void;
+    /**
+     * Sends an error start event for this async tool call
+     * @param args - Error details including optional error ID and message
+     * @internal
+     */
+    sendErrorStart(args: {
+        errorId?: string;
+    } & ErrorStartEvent): void;
+    /**
+     * Sends an error end event for this async tool call
+     * @param args - Error end details including the error ID
+     * @internal
+     */
+    sendErrorEnd(args: {
+        errorId: string;
+    } & ErrorEndEvent): void;
+    /**
+     * Sends a metadata event for this async tool call
+     * @param metaEvent - Metadata to send
+     * @internal
+     */
+    sendMetaEvent(metaEvent: MetaEvent): void;
+    /**
+     * Emits a raw tool call event
+     * @param toolCallEvent - The event to emit (toolCallId is added automatically)
+     * @internal
+     */
+    emit(toolCallEvent: Omit<ToolCallEvent, 'toolCallId'>): void;
+    /**
+     * Returns a string representation of this async tool call
+     * @internal
+     */
+    toString(): string;
+}
+
+/**
+ * Consumer-facing interface for AsyncInputStreamEventHelper
+ *
+ * Defines the public API for interacting with async input streams
+ * at the session level. Async input streams are used for streaming
+ * audio or other media data to the agent.
+ */
+
+/**
+ * Consumer-facing model for async input stream event helpers.
+ *
+ * Async input streams operate at the session level and are used for
+ * streaming audio or other media data to the agent in real-time.
+ * They persist across exchanges, making them ideal for continuous
+ * audio input from a microphone.
+ *
+ * Unlike content parts (which carry agent output), async input streams
+ * carry user input to the agent via the {@link SessionStream}.
+ *
+ * @example Streaming microphone audio
+ * ```typescript
+ * const stream = session.startAsyncInputStream({
+ *   mimeType: 'audio/pcm;rate=24000'
+ * });
+ *
+ * // Stream microphone PCM data
+ * microphone.on('data', (pcmData: string) => {
+ *   stream.sendChunk({ data: pcmData });
+ * });
+ *
+ * // End when user stops speaking
+ * microphone.on('end', () => {
+ *   stream.sendAsyncInputStreamEnd();
+ * });
+ * ```
+ *
+ * @example Receiving audio input (agent-side)
+ * ```typescript
+ * session.onInputStreamStart((inputStream) => {
+ *   console.log(`Receiving audio: ${inputStream.startEvent.mimeType}`);
+ *
+ *   inputStream.onChunk((chunk) => {
+ *     // Process incoming audio data
+ *     audioProcessor.process(chunk.data);
+ *   });
+ *
+ *   inputStream.onAsyncInputStreamEnd(() => {
+ *     console.log('Audio stream ended');
+ *   });
+ * });
+ * ```
+ *
+ * @example Handling stream errors
+ * ```typescript
+ * const stream = session.startAsyncInputStream({
+ *   mimeType: 'audio/pcm;rate=24000'
+ * });
+ *
+ * stream.onErrorStart((error) => {
+ *   console.error(`Stream error: ${error.message}`);
+ *   // Clean up microphone resources
+ *   microphone.stop();
+ * });
+ * ```
+ */
+interface AsyncInputStream {
+    /** Unique identifier for this input stream */
+    readonly streamId: string;
+    /**
+     * The start event, or undefined if not yet received
+     * @internal
+     */
+    readonly startEventMaybe: AsyncInputStreamStartEvent | undefined;
+    /**
+     * The start event (throws if not yet received)
+     * @internal
+     */
+    readonly startEvent: AsyncInputStreamStartEvent;
+    /** Whether this input stream has ended */
+    readonly ended: boolean;
+    /**
+     * Registers a handler for error start events
+     * @param cb - Callback receiving the error event
+     * @returns Cleanup function to remove the handler
+     */
+    onErrorStart(cb: (error: {
+        errorId: string;
+    } & ErrorStartEvent) => void): () => void;
+    /**
+     * Registers a handler for error end events
+     * @param cb - Callback receiving the error end event
+     * @returns Cleanup function to remove the handler
+     */
+    onErrorEnd(cb: (error: {
+        errorId: string;
+    } & ErrorEndEvent) => void): () => void;
+    /**
+     * Sends a stream chunk
+     * @param chunk - Chunk data to send (e.g., audio data)
+     */
+    sendChunk(chunk: AsyncInputStreamChunkEvent): void;
+    /**
+     * Registers a handler for stream chunks
+     * @param cb - Callback receiving each chunk
+     * @returns Cleanup function to remove the handler
+     */
+    onChunk(cb: (chunk: AsyncInputStreamChunkEvent) => void): () => void;
+    /**
+     * Ends the input stream
+     * @param endAsyncInputStream - Optional end event data
+     */
+    sendAsyncInputStreamEnd(endAsyncInputStream?: AsyncInputStreamEndEvent): void;
+    /**
+     * Registers a handler for stream end events
+     * @param cb - Callback receiving the end event
+     * @returns Cleanup function to remove the handler
+     */
+    onAsyncInputStreamEnd(cb: (endAsyncInputStream: AsyncInputStreamEndEvent) => void): () => void;
+    /**
+     * Sends an error start event for this stream
+     * @param args - Error details including optional error ID and message
+     * @internal
+     */
+    sendErrorStart(args: {
+        errorId?: string;
+    } & ErrorStartEvent): void;
+    /**
+     * Sends an error end event for this stream
+     * @param args - Error end details including the error ID
+     * @internal
+     */
+    sendErrorEnd(args: {
+        errorId: string;
+    } & ErrorEndEvent): void;
+    /**
+     * Sends a metadata event for this stream
+     * @param metaEvent - Metadata to send
+     * @internal
+     */
+    sendMetaEvent(metaEvent: MetaEvent): void;
+    /**
+     * Emits a raw async input stream event
+     * @param streamEvent - The event to emit (streamId is added automatically)
+     * @internal
+     */
+    emit(streamEvent: Omit<AsyncInputStreamEvent, 'streamId'>): void;
+    /**
+     * Returns a string representation of this input stream
+     * @internal
+     */
+    toString(): string;
+}
+
+/**
+ * Consumer-facing interface for MessageEventHelper
+ *
+ * Defines the public API for interacting with message events
+ * within an exchange. Messages represent individual turns from
+ * users, assistants, or the system.
+ */
+
+/**
+ * Aggregated data for a completed message
+ *
+ * Contains all content parts, tool calls, and metadata
+ * available after a message stream has ended.
+ */
+type CompletedMessage = Simplify<{
+    messageId: string;
+    contentParts: Array<CompletedContentPart>;
+    toolCalls: Array<CompletedToolCall>;
+} & Partial<MessageStartEvent> & MessageEndEvent>;
+/**
+ * Consumer-facing model for message event helpers.
+ *
+ * A message represents a single turn from a user, assistant, or system.
+ * Messages contain content parts (text, audio, images) and tool calls.
+ * The `role` property and convenience booleans (`isUser`, `isAssistant`,
+ * `isSystem`) let you filter by sender.
+ *
+ * @example Streaming text with real-time output
+ * ```typescript
+ * exchange.onMessageStart((message) => {
+ *   if (message.isAssistant) {
+ *     message.onContentPartStart((part) => {
+ *       if (part.isMarkdown) {
+ *         part.onChunk((chunk) => {
+ *           process.stdout.write(chunk.data ?? '');
+ *         });
+ *       }
+ *     });
+ *   }
+ * });
+ * ```
+ *
+ * @example Handling tool calls with confirmation interrupts
+ * ```typescript
+ * exchange.onMessageStart((message) => {
+ *   if (message.isAssistant) {
+ *     message.onToolCallStart((toolCall) => {
+ *       console.log(`Tool: ${toolCall.startEvent.toolName}`);
+ *     });
+ *
+ *     message.onInterruptStart(({ interruptId, startEvent }) => {
+ *       if (startEvent.type === 'uipath_cas_tool_call_confirmation') {
+ *         message.sendInterruptEnd(interruptId, { approved: true });
+ *       }
+ *     });
+ *   }
+ * });
+ * ```
+ *
+ * @example Getting the complete message at once (buffered)
+ * ```typescript
+ * exchange.onMessageStart((message) => {
+ *   if (message.isAssistant) {
+ *     message.onCompleted((completed) => {
+ *       console.log(`Message ${completed.messageId} finished`);
+ *       for (const part of completed.contentParts) {
+ *         console.log(part.data);
+ *       }
+ *       for (const tool of completed.toolCalls) {
+ *         console.log(`${tool.toolName} → ${tool.output}`);
+ *       }
+ *     });
+ *   }
+ * });
+ * ```
+ *
+ * @example Sending a content part with convenience method
+ * ```typescript
+ * const message = exchange.startMessage({ role: MessageRole.User });
+ * await message.sendContentPart({ data: 'Hello!', mimeType: 'text/plain' });
+ * message.sendMessageEnd();
+ * ```
+ */
+interface MessageStream {
+    /** Unique identifier for this message */
+    readonly messageId: string;
+    /** The role of this message sender, or undefined if start event not yet received */
+    readonly role: MessageRole | undefined;
+    /** Whether this message is from the user */
+    readonly isUser: boolean;
+    /** Whether this message is from the assistant */
+    readonly isAssistant: boolean;
+    /** Whether this message is a system message */
+    readonly isSystem: boolean;
+    /**
+     * The start event, or undefined if not yet received
+     * @internal
+     */
+    readonly startEventMaybe: MessageStartEvent | undefined;
+    /**
+     * The start event (throws if not yet received)
+     * @internal
+     */
+    readonly startEvent: MakeRequired<MessageStartEvent, 'timestamp'>;
+    /** Whether this message has ended */
+    readonly ended: boolean;
+    /**
+     * Registers a handler for error start events
+     *
+     * @param cb - Callback receiving the error event
+     * @returns Cleanup function to remove the handler
+     *
+     * @example Message-level error handling
+     * ```typescript
+     * message.onErrorStart((error) => {
+     *   console.error(`Message error [${error.errorId}]: ${error.message}`);
+     * });
+     * ```
+     */
+    onErrorStart(cb: (error: {
+        errorId: string;
+    } & ErrorStartEvent) => void): () => void;
+    /**
+     * Registers a handler for error end events
+     * @param cb - Callback receiving the error end event
+     * @returns Cleanup function to remove the handler
+     */
+    onErrorEnd(cb: (error: {
+        errorId: string;
+    } & ErrorEndEvent) => void): () => void;
+    /**
+     * Registers a handler for content part start events
+     *
+     * Content parts are streamed pieces of content (text, audio, images,
+     * transcripts). Use `part.isMarkdown`, `part.isAudio`, etc. to determine type.
+     *
+     * @param cb - Callback receiving each new content part
+     * @returns Cleanup function to remove the handler
+     *
+     * @example Streaming text and handling different content types
+     * ```typescript
+     * message.onContentPartStart((part) => {
+     *   if (part.isMarkdown) {
+     *     part.onChunk((chunk) => renderMarkdown(chunk.data ?? ''));
+     *   } else if (part.isAudio) {
+     *     part.onChunk((chunk) => audioPlayer.enqueue(chunk.data ?? ''));
+     *   } else if (part.isImage) {
+     *     part.onChunk((chunk) => imageBuffer.append(chunk.data ?? ''));
+     *   } else if (part.isTranscript) {
+     *     part.onChunk((chunk) => showTranscript(chunk.data ?? ''));
+     *   }
+     * });
+     * ```
+     */
+    onContentPartStart(cb: (contentPart: ContentPartStream) => void): () => void;
+    /**
+     * Registers a handler for tool call start events
+     *
+     * Tool calls represent the agent invoking external tools. Each tool call
+     * has a name, input, and eventually an output when it completes.
+     *
+     * @param cb - Callback receiving each new tool call
+     * @returns Cleanup function to remove the handler
+     *
+     * @example Streaming tool call events
+     * ```typescript
+     * message.onToolCallStart((toolCall) => {
+     *   const { toolName, input } = toolCall.startEvent;
+     *   console.log(`Calling ${toolName}:`, JSON.parse(input ?? '{}'));
+     *
+     *   toolCall.onToolCallEnd((end) => {
+     *     console.log(`Result:`, JSON.parse(end.output ?? '{}'));
+     *   });
+     * });
+     * ```
+     */
+    onToolCallStart(cb: (toolCall: ToolCallStream) => void): () => void;
+    /**
+     * Registers a handler for message end events
+     *
+     * @param cb - Callback receiving the end event
+     * @returns Cleanup function to remove the handler
+     *
+     * @example Tracking message lifecycle
+     * ```typescript
+     * message.onMessageEnd((endEvent) => {
+     *   console.log('Message ended');
+     * });
+     * ```
+     */
+    onMessageEnd(cb: (endMessage: MessageEndEvent) => void): () => void;
+    /**
+     * Registers a handler called when a content part finishes
+     *
+     * Convenience method that combines onContentPartStart + onContentPartEnd.
+     * The handler receives the full buffered content part data including
+     * text, citations, and any citation errors.
+     *
+     * @param cb - Callback receiving the completed content part data
+     *
+     * @example Getting completed content parts with citations
+     * ```typescript
+     * message.onContentPartCompleted((completed) => {
+     *   console.log(`[${completed.mimeType}] ${completed.data}`);
+     *
+     *   // Access citations if present
+     *   for (const citation of completed.citations) {
+     *     const citedText = completed.data.substring(citation.offset, citation.offset + citation.length);
+     *     console.log(`Citation "${citedText}" from:`, citation.sources);
+     *   }
+     *
+     *   // Check for citation errors
+     *   for (const error of completed.citationErrors) {
+     *     console.warn(`Citation error [${error.citationId}]: ${error.errorType}`);
+     *   }
+     * });
+     * ```
+     */
+    onContentPartCompleted(cb: (completedContentPart: CompletedContentPart) => void): void;
+    /**
+     * Registers a handler called when a tool call finishes
+     *
+     * Convenience method that combines onToolCallStart + onToolCallEnd.
+     * The handler receives the merged start and end event data.
+     *
+     * @param cb - Callback receiving the completed tool call data
+     *
+     * @example Getting completed tool calls
+     * ```typescript
+     * message.onToolCallCompleted((toolCall) => {
+     *   console.log(`Tool: ${toolCall.toolName}`);
+     *   console.log(`Input: ${toolCall.input}`);
+     *   console.log(`Output: ${toolCall.output}`);
+     * });
+     * ```
+     */
+    onToolCallCompleted(cb: (completedToolCall: CompletedToolCall) => void): void;
+    /**
+     * Registers a handler called when the entire message finishes
+     *
+     * The handler receives the aggregated message data including
+     * all completed content parts and tool calls.
+     *
+     * @param cb - Callback receiving the completed message data
+     *
+     * @example Getting the full buffered message
+     * ```typescript
+     * message.onCompleted((completed) => {
+     *   console.log(`Message ${completed.messageId} (role: ${completed.role})`);
+     *   console.log('Text:', completed.contentParts.map(p => p.data).join(''));
+     *   console.log('Tool calls:', completed.toolCalls.length);
+     * });
+     * ```
+     */
+    onCompleted(cb: (completedMessage: CompletedMessage) => void): void;
+    /**
+     * Registers a handler for interrupt start events
+     *
+     * Interrupts represent pause points where the agent needs external input,
+     * such as tool call confirmation requests.
+     *
+     * @param cb - Callback receiving the interrupt ID and start event
+     * @returns Cleanup function to remove the handler
+     *
+     * @example Handling tool call confirmation
+     * ```typescript
+     * message.onInterruptStart(({ interruptId, startEvent }) => {
+     *   if (startEvent.type === 'uipath_cas_tool_call_confirmation') {
+     *     // Show confirmation UI, then respond
+     *     message.sendInterruptEnd(interruptId, { approved: true });
+     *   }
+     * });
+     * ```
+     */
+    onInterruptStart(cb: (interrupt: {
+        interruptId: string;
+        startEvent: InterruptStartEvent;
+    }) => void): () => void;
+    /**
+     * Registers a handler for interrupt end events
+     *
+     * @param cb - Callback receiving the interrupt ID and end event
+     * @returns Cleanup function to remove the handler
+     *
+     * @example Tracking interrupt resolution
+     * ```typescript
+     * message.onInterruptEnd(({ interruptId, endEvent }) => {
+     *   console.log(`Interrupt ${interruptId} resolved`);
+     * });
+     * ```
+     */
+    onInterruptEnd(cb: (interrupt: {
+        interruptId: string;
+        endEvent: InterruptEndEvent;
+    }) => void): () => void;
+    /**
+     * Sends an interrupt end event to resolve a pending interrupt
+     *
+     * Call this to respond to an interrupt received via onInterruptStart.
+     *
+     * @param interruptId - The interrupt ID to respond to
+     * @param endInterrupt - The response data (e.g., approval for tool call confirmation)
+     *
+     * @example Approving a tool call confirmation
+     * ```typescript
+     * message.sendInterruptEnd(interruptId, { approved: true });
+     * ```
+     */
+    sendInterruptEnd(interruptId: string, endInterrupt: InterruptEndEvent): void;
+    /**
+     * Starts a new content part stream in this message
+     *
+     * Use this for streaming content in chunks. For sending
+     * complete content in one call, prefer {@link sendContentPart}.
+     *
+     * @param args - Content part start options including mime type
+     * @returns The content part stream for sending chunks
+     *
+     * @example Streaming text content in chunks
+     * ```typescript
+     * const part = message.startContentPart({ mimeType: 'text/markdown' });
+     * part.sendChunk({ data: '# Hello\n' });
+     * part.sendChunk({ data: 'This is **markdown** content.' });
+     * part.sendContentPartEnd();
+     * ```
+     */
+    startContentPart(args: {
+        contentPartId?: string;
+    } & ContentPartStartEvent): ContentPartStream;
+    /**
+     * Sends a complete content part with data in one step
+     *
+     * Convenience method that creates a content part, sends the data as a chunk,
+     * and ends the content part. Defaults to mimeType "text/markdown".
+     *
+     * @param args - Content part data and optional mime type
+     *
+     * @example Sending a text content part
+     * ```typescript
+     * await message.sendContentPart({ data: 'Hello world!' });
+     * ```
+     *
+     * @example Sending with explicit mime type
+     * ```typescript
+     * await message.sendContentPart({
+     *   data: 'Plain text content',
+     *   mimeType: 'text/plain'
+     * });
+     * ```
+     */
+    sendContentPart(args: {
+        data?: string;
+        mimeType?: string;
+    }): Promise<void>;
+    /**
+     * Iterator over all active content parts in this message
+     */
+    readonly contentParts: Iterable<ContentPartStream>;
+    /**
+     * Retrieves a content part by ID
+     * @param contentPartId - The content part ID to look up
+     * @returns The content part stream, or undefined if not found
+     */
+    getContentPart(contentPartId: string): ContentPartStream | undefined;
+    /**
+     * Starts a new tool call in this message
+     *
+     * @param args - Tool call start options including tool name
+     * @returns The tool call stream for managing the tool call lifecycle
+     *
+     * @example Creating and completing a tool call
+     * ```typescript
+     * const toolCall = message.startToolCall({
+     *   toolName: 'get-weather',
+     *   input: JSON.stringify({ city: 'London' })
+     * });
+     * toolCall.sendToolCallEnd({
+     *   output: JSON.stringify({ temperature: 18, condition: 'cloudy' })
+     * });
+     * ```
+     */
+    startToolCall(args: {
+        toolCallId?: string;
+    } & ToolCallStartEvent): ToolCallStream;
+    /**
+     * Iterator over all active tool calls in this message
+     */
+    readonly toolCalls: Iterable<ToolCallStream>;
+    /**
+     * Retrieves a tool call by ID
+     * @param toolCallId - The tool call ID to look up
+     * @returns The tool call stream, or undefined if not found
+     */
+    getToolCall(toolCallId: string): ToolCallStream | undefined;
+    /**
+     * Ends the message
+     *
+     * @param endMessage - Optional end event data
+     *
+     * @example Ending a message
+     * ```typescript
+     * message.sendMessageEnd();
+     * ```
+     */
+    sendMessageEnd(endMessage?: MessageEndEvent): void;
+    /**
+     * Sends an error start event for this message
+     * @param args - Error details including optional error ID and message
+     * @internal
+     */
+    sendErrorStart(args: {
+        errorId?: string;
+    } & ErrorStartEvent): void;
+    /**
+     * Sends an error end event for this message
+     * @param args - Error end details including the error ID
+     * @internal
+     */
+    sendErrorEnd(args: {
+        errorId: string;
+    } & ErrorEndEvent): void;
+    /**
+     * Sends a metadata event for this message
+     * @param metaEvent - Metadata to send
+     * @internal
+     */
+    sendMetaEvent(metaEvent: MetaEvent): void;
+    /**
+     * Emits a raw message event
+     * @param messageEvent - The event to emit (messageId is added automatically)
+     * @internal
+     */
+    emit(messageEvent: Omit<MessageEvent, 'messageId'>): void;
+    /**
+     * Sends an interrupt start event
+     * @param interruptId - The interrupt ID
+     * @param startInterrupt - The interrupt start event data
+     * @internal
+     */
+    sendInterrupt(interruptId: string, startInterrupt: InterruptStartEvent): void;
+    /**
+     * Returns a string representation of this message
+     * @internal
+     */
+    toString(): string;
+}
+
+/**
+ * Consumer-facing interface for ExchangeEventHelper
+ *
+ * Defines the public API for interacting with exchange events
+ * within a session. Exchanges represent request-response pairs
+ * containing user and assistant messages.
+ */
+
+/**
+ * Consumer-facing model for exchange event helpers.
+ *
+ * An exchange represents a single request-response cycle within a session.
+ * Each exchange contains one or more messages (typically a user message
+ * followed by an assistant response). Use exchanges to group related
+ * turns in a multi-turn conversation.
+ *
+ * @example Streaming assistant response
+ * ```typescript
+ * session.onExchangeStart((exchange) => {
+ *   exchange.onMessageStart((message) => {
+ *     if (message.isAssistant) {
+ *       message.onContentPartStart((part) => {
+ *         if (part.isMarkdown) {
+ *           part.onChunk((chunk) => {
+ *             process.stdout.write(chunk.data ?? '');
+ *           });
+ *         }
+ *       });
+ *     }
+ *   });
+ * });
+ * ```
+ *
+ * @example Getting the completed message at once (no streaming)
+ * ```typescript
+ * session.onExchangeStart((exchange) => {
+ *   exchange.onMessageCompleted((completed) => {
+ *     for (const part of completed.contentParts) {
+ *       console.log(part.data);
+ *     }
+ *     for (const tool of completed.toolCalls) {
+ *       console.log(`${tool.toolName}: ${tool.output}`);
+ *     }
+ *   });
+ * });
+ * ```
+ *
+ * @example Sending a user message with convenience method
+ * ```typescript
+ * // Call startExchange inside onSessionStarted to ensure the session is ready
+ * session.onSessionStarted(() => {
+ *   const exchange = session.startExchange();
+ *   exchange.sendMessageWithContentPart({
+ *     data: 'Hello, how can you help me?',
+ *     role: MessageRole.User
+ *   });
+ * });
+ * ```
+ *
+ * @example Sending a user message with streaming parts
+ * ```typescript
+ * // Call startExchange inside onSessionStarted to ensure the session is ready
+ * session.onSessionStarted(() => {
+ *   const exchange = session.startExchange();
+ *   const message = exchange.startMessage({ role: MessageRole.User });
+ *   const part = message.startContentPart({ mimeType: 'text/plain' });
+ *   part.sendChunk({ data: 'Hello, ' });
+ *   part.sendChunk({ data: 'how can you help me?' });
+ *   part.sendContentPartEnd();
+ *   message.sendMessageEnd();
+ * });
+ * ```
+ */
+interface ExchangeStream {
+    /** Unique identifier for this exchange */
+    readonly exchangeId: string;
+    /**
+     * The start event, or undefined if not yet received
+     * @internal
+     */
+    readonly startEventMaybe: ExchangeStartEvent | undefined;
+    /**
+     * The start event (throws if not yet received)
+     * @internal
+     */
+    readonly startEvent: MakeRequired<ExchangeStartEvent, 'timestamp'>;
+    /** Whether this exchange has ended */
+    readonly ended: boolean;
+    /**
+     * Registers a handler for error start events
+     *
+     * @param cb - Callback receiving the error event
+     * @returns Cleanup function to remove the handler
+     *
+     * @example Exchange-level error handling
+     * ```typescript
+     * exchange.onErrorStart((error) => {
+     *   console.error(`Exchange error [${error.errorId}]: ${error.message}`);
+     * });
+     * ```
+     */
+    onErrorStart(cb: (error: {
+        errorId: string;
+    } & ErrorStartEvent) => void): () => void;
+    /**
+     * Registers a handler for error end events
+     * @param cb - Callback receiving the error end event
+     * @returns Cleanup function to remove the handler
+     */
+    onErrorEnd(cb: (error: {
+        errorId: string;
+    } & ErrorEndEvent) => void): () => void;
+    /**
+     * Registers a handler for message start events
+     *
+     * Each exchange typically contains a user message and an assistant
+     * response. Use `message.isAssistant` or `message.isUser` to filter.
+     *
+     * @param cb - Callback receiving each new message
+     * @returns Cleanup function to remove the handler
+     *
+     * @example Filtering by message role
+     * ```typescript
+     * exchange.onMessageStart((message) => {
+     *   if (message.isAssistant) {
+     *     message.onContentPartStart((part) => {
+     *       if (part.isMarkdown) {
+     *         part.onChunk((chunk) => process.stdout.write(chunk.data ?? ''));
+     *       }
+     *     });
+     *   }
+     * });
+     * ```
+     */
+    onMessageStart(cb: (message: MessageStream) => void): () => void;
+    /**
+     * Registers a handler for exchange end events
+     *
+     * @param cb - Callback receiving the end event
+     * @returns Cleanup function to remove the handler
+     *
+     * @example Tracking exchange lifecycle
+     * ```typescript
+     * exchange.onExchangeEnd((endEvent) => {
+     *   console.log('Exchange completed');
+     * });
+     * ```
+     */
+    onExchangeEnd(cb: (endExchange: ExchangeEndEvent) => void): () => void;
+    /**
+     * Registers a handler called when a message finishes
+     *
+     * Convenience method that combines onMessageStart + message.onCompleted.
+     * The handler receives the aggregated message data including all
+     * content parts and tool calls.
+     *
+     * @param cb - Callback receiving the completed message data
+     *
+     * @example Getting buffered message with all content and tool calls
+     * ```typescript
+     * exchange.onMessageCompleted((message) => {
+     *   console.log(`Message ${message.messageId} (role: ${message.role})`);
+     *   console.log(`Content parts: ${message.contentParts.length}`);
+     *   console.log(`Tool calls: ${message.toolCalls.length}`);
+     * });
+     * ```
+     */
+    onMessageCompleted(cb: (completedMessage: CompletedMessage) => void): void;
+    /**
+     * Starts a new message in this exchange
+     *
+     * Use this for fine-grained control over message construction.
+     * For simple text messages, prefer {@link sendMessageWithContentPart}.
+     *
+     * @param args - Optional message start options including role
+     * @returns The message stream for sending content
+     *
+     * @example Building a message with multiple content parts
+     * ```typescript
+     * const message = exchange.startMessage({ role: MessageRole.User });
+     * const part = message.startContentPart({ mimeType: 'text/plain' });
+     * part.sendChunk({ data: 'Analyze this image: ' });
+     * part.sendContentPartEnd();
+     * message.sendMessageEnd();
+     * ```
+     */
+    startMessage(args?: {
+        messageId?: string;
+    } & Partial<MessageStartEvent>): MessageStream;
+    /**
+     * Sends a complete message with a content part in one step
+     *
+     * Convenience method that creates a message, adds a content part with the given data,
+     * and ends both the content part and message.
+     *
+     * @param options - Message content options
+     *
+     * @example Sending a user message
+     * ```typescript
+     * await exchange.sendMessageWithContentPart({
+     *   data: 'What is the weather today?',
+     *   role: MessageRole.User
+     * });
+     * ```
+     */
+    sendMessageWithContentPart(options: {
+        data: string;
+        role?: MessageRole;
+        mimeType?: string;
+    }): Promise<void>;
+    /**
+     * Iterator over all active messages in this exchange
+     */
+    readonly messages: Iterable<MessageStream>;
+    /**
+     * Retrieves a message by ID
+     * @param messageId - The message ID to look up
+     * @returns The message stream, or undefined if not found
+     */
+    getMessage(messageId: string): MessageStream | undefined;
+    /**
+     * Ends the exchange
+     *
+     * @param endExchange - Optional end event data
+     *
+     * @example Manually ending an exchange
+     * ```typescript
+     * exchange.sendExchangeEnd();
+     * ```
+     */
+    sendExchangeEnd(endExchange?: ExchangeEndEvent): void;
+    /**
+     * Sends an error start event for this exchange
+     * @param args - Error details including optional error ID and message
+     * @internal
+     */
+    sendErrorStart(args: {
+        errorId?: string;
+    } & ErrorStartEvent): void;
+    /**
+     * Sends an error end event for this exchange
+     * @param args - Error end details including the error ID
+     * @internal
+     */
+    sendErrorEnd(args: {
+        errorId: string;
+    } & ErrorEndEvent): void;
+    /**
+     * Sends a metadata event for this exchange
+     * @param metaEvent - Metadata to send
+     * @internal
+     */
+    sendMetaEvent(metaEvent: MetaEvent): void;
+    /**
+     * Emits a raw exchange event
+     * @param exchangeEvent - The event to emit (exchangeId is added automatically)
+     * @internal
+     */
+    emit(exchangeEvent: Omit<ExchangeEvent, 'exchangeId'>): void;
+    /**
+     * Returns a string representation of this exchange
+     * @internal
+     */
+    toString(): string;
+}
+
+/**
+ * Consumer-facing interface for SessionEventHelper
+ *
+ * Defines the public API for interacting with a real-time
+ * conversation session. Sessions are the top-level container
+ * for exchanges, messages, and streaming content.
+ */
+
+/**
+ * Real-time WebSocket session for two-way communication within a {@link ConversationServiceModel | Conversation}.
+ *
+ * Send messages and receive agent responses through a nested stream hierarchy.
+ * The `SessionStream` is the top-level entry point — events flow down through
+ * exchanges, messages, content parts, and tool calls.
+ *
+ * ### Usage
+ *
+ * **Important:** Always wait for `onSessionStarted` before calling
+ * `startExchange`. The session must be fully connected via WebSocket
+ * before exchanges can be sent — calling `startExchange` earlier may
+ * lose events or cause errors.
+ *
+ * ```typescript
+ * const session = conversation.startSession();
+ *
+ * // Set up handlers for incoming assistant responses
+ * session.onExchangeStart((exchange) => {
+ *   exchange.onMessageStart((message) => {
+ *     if (message.isAssistant) {
+ *       message.onContentPartStart((part) => {
+ *         if (part.isMarkdown) {
+ *           part.onChunk((chunk) => {
+ *             process.stdout.write(chunk.data ?? '');
+ *           });
+ *         }
+ *       });
+ *     }
+ *   });
+ * });
+ *
+ * // Wait for the session to be ready, then send a message
+ * session.onSessionStarted(() => {
+ *   const exchange = session.startExchange();
+ *   exchange.sendMessageWithContentPart({
+ *     data: 'Hello!',
+ *     role: MessageRole.User
+ *   });
+ * });
+ *
+ * // End the session when done
+ * conversation.endSession();
+ * ```
+ *
+ * ### Related Streams
+ *
+ * | Stream | Description |
+ * | --- | --- |
+ * | {@link ExchangeStream} | A single request-response cycle within a session. Contains user and assistant messages. |
+ * | {@link MessageStream} | A single message (user, assistant, or system). Contains content parts and tool calls. |
+ * | {@link ContentPartStream} | A piece of streamed content (text, audio, image, transcript). Delivers data via `onChunk`. |
+ * | {@link ToolCallStream} | An external tool invocation by the assistant. Has a start event (name, input) and end event (output). |
+ */
+interface SessionStream {
+    /** The conversation ID this session belongs to */
+    readonly conversationId: string;
+    /**
+     * Whether echo mode is enabled (emitted events are also dispatched to handlers)
+     * @internal
+     */
+    readonly echo: boolean;
+    /**
+     * The start event, or undefined if not yet received
+     * @internal
+     */
+    readonly startEventMaybe: SessionStartEvent | undefined;
+    /**
+     * The start event (throws if not yet received)
+     * @internal
+     */
+    readonly startEvent: SessionStartEvent;
+    /** Whether this session has ended */
+    readonly ended: boolean;
+    /**
+     * Whether event emitting is currently paused
+     * @internal
+     */
+    readonly isEmitPaused: boolean;
+    /**
+     * Pauses emitting events to the WebSocket
+     *
+     * Events are buffered internally and sent when `resumeEmits` is called.
+     * Useful when you need to set up event handlers before events start flowing
+     * (e.g., between starting a session and receiving the session started event).
+     * @internal
+     */
+    pauseEmits(): void;
+    /**
+     * Resumes emitting events and flushes any buffered events
+     *
+     * All events that were buffered while paused are sent in order.
+     * @internal
+     */
+    resumeEmits(): void;
+    /**
+     * Registers a handler for error start events at the session level
+     *
+     * @param cb - Callback receiving the error event
+     * @returns Cleanup function to remove the handler
+     *
+     * @example
+     * ```typescript
+     * session.onErrorStart((error) => {
+     *   console.error(`Session error [${error.errorId}]: ${error.message}`);
+     * });
+     * ```
+     */
+    onErrorStart(cb: (error: {
+        errorId: string;
+    } & ErrorStartEvent) => void): () => void;
+    /**
+     * Registers a handler for error end events at the session level
+     *
+     * @param cb - Callback receiving the error end event
+     * @returns Cleanup function to remove the handler
+     *
+     * @example
+     * ```typescript
+     * session.onErrorEnd((error) => {
+     *   console.log(`Error ${error.errorId} resolved`);
+     * });
+     * ```
+     */
+    onErrorEnd(cb: (error: {
+        errorId: string;
+    } & ErrorEndEvent) => void): () => void;
+    /**
+     * Registers a handler for exchange start events
+     *
+     * This is the primary entry point for handling agent responses.
+     * Each exchange represents a request-response cycle containing
+     * user and assistant messages.
+     *
+     * @param cb - Callback receiving each new exchange
+     * @returns Cleanup function to remove the handler
+     *
+     * @example Streaming text with content type handling
+     * ```typescript
+     * session.onExchangeStart((exchange) => {
+     *   exchange.onMessageStart((message) => {
+     *     if (message.isAssistant) {
+     *       message.onContentPartStart((part) => {
+     *         if (part.isMarkdown) {
+     *           part.onChunk((chunk) => renderMarkdown(chunk.data ?? ''));
+     *         } else if (part.isAudio) {
+     *           part.onChunk((chunk) => audioPlayer.enqueue(chunk.data ?? ''));
+     *         } else if (part.isImage) {
+     *           part.onChunk((chunk) => imageBuffer.append(chunk.data ?? ''));
+     *         } else if (part.isTranscript) {
+     *           part.onChunk((chunk) => showTranscript(chunk.data ?? ''));
+     *         }
+     *       });
+     *     }
+     *   });
+     * });
+     * ```
+     *
+     * @example Getting the complete response at once (no streaming)
+     * ```typescript
+     * session.onExchangeStart((exchange) => {
+     *   exchange.onMessageCompleted((completed) => {
+     *     console.log(`Message ${completed.messageId} (role: ${completed.role})`);
+     *     for (const part of completed.contentParts) {
+     *       console.log(part.data);
+     *     }
+     *     for (const tool of completed.toolCalls) {
+     *       console.log(`${tool.toolName} → ${tool.output}`);
+     *     }
+     *   });
+     * });
+     * ```
+     *
+     * @example Handling tool calls and confirmation interrupts
+     * ```typescript
+     * session.onExchangeStart((exchange) => {
+     *   exchange.onMessageStart((message) => {
+     *     if (message.isAssistant) {
+     *       // Stream tool call events
+     *       message.onToolCallStart((toolCall) => {
+     *         const { toolName, input } = toolCall.startEvent;
+     *         console.log(`Calling ${toolName}:`, JSON.parse(input ?? '{}'));
+     *         toolCall.onToolCallEnd((end) => {
+     *           console.log(`Result:`, JSON.parse(end.output ?? '{}'));
+     *         });
+     *       });
+     *
+     *       // Handle confirmation interrupts
+     *       message.onInterruptStart(({ interruptId, startEvent }) => {
+     *         if (startEvent.type === 'uipath_cas_tool_call_confirmation') {
+     *           message.sendInterruptEnd(interruptId, { approved: true });
+     *         }
+     *       });
+     *     }
+     *   });
+     * });
+     * ```
+     */
+    onExchangeStart(cb: (exchange: ExchangeStream) => void): () => void;
+    /**
+     * Registers a handler for session started events
+     *
+     * Fired when the WebSocket connection is established and the
+     * session is ready to send and receive events.
+     *
+     * @param cb - Callback receiving the started event
+     * @returns Cleanup function to remove the handler
+     *
+     * @example
+     * ```typescript
+     * session.onSessionStarted(() => {
+     *   console.log('Session is ready — now safe to start exchanges');
+     *
+     *   const exchange = session.startExchange();
+     *   exchange.sendMessageWithContentPart({
+     *     data: 'Hello!',
+     *     role: MessageRole.User
+     *   });
+     * });
+     * ```
+     */
+    onSessionStarted(cb: (event: SessionStartedEvent) => void): () => void;
+    /**
+     * Registers a handler for session ending events
+     *
+     * Fired when the session is about to end. Use this for cleanup
+     * before the session fully closes.
+     *
+     * @param cb - Callback receiving the ending event
+     * @returns Cleanup function to remove the handler
+     *
+     * @example
+     * ```typescript
+     * session.onSessionEnding((event) => {
+     *   console.log('Session is ending, performing cleanup...');
+     * });
+     * ```
+     */
+    onSessionEnding(cb: (event: SessionEndingEvent) => void): () => void;
+    /**
+     * Registers a handler for session end events
+     *
+     * Fired when the session has fully closed.
+     *
+     * @param cb - Callback receiving the end event
+     * @returns Cleanup function to remove the handler
+     *
+     * @example
+     * ```typescript
+     * session.onSessionEnd((event) => {
+     *   console.log('Session ended');
+     * });
+     * ```
+     */
+    onSessionEnd(cb: (event: SessionEndEvent) => void): () => void;
+    /**
+     * Registers a handler for conversation label updates
+     *
+     * Fired when the conversation label changes, typically when the server
+     * auto-generates a title based on the first message.
+     *
+     * @param cb - Callback receiving the {@link LabelUpdatedEvent} with the new label
+     * @returns Cleanup function to remove the handler
+     *
+     * @example
+     * ```typescript
+     * session.onLabelUpdated((event) => {
+     *   console.log(`New label: ${event.label} (auto: ${event.autogenerated})`);
+     *   updateConversationTitle(event.label);
+     * });
+     * ```
+     */
+    onLabelUpdated(cb: (event: LabelUpdatedEvent) => void): () => void;
+    /**
+     * Sends a session started event
+     * @param sessionStarted - Optional started event data
+     * @internal
+     */
+    sendSessionStarted(sessionStarted?: SessionStartedEvent): void;
+    /**
+     * Sends a session end event and closes the session
+     *
+     * Prefer using `conversation.endSession()` instead of calling this directly.
+     *
+     * @param endSession - Optional end event data
+     * @internal
+     */
+    sendSessionEnd(endSession?: SessionEndEvent): void;
+    /**
+     * Sends an error start event for this session
+     * @param args - Error details including optional error ID and message
+     * @internal
+     */
+    sendErrorStart(args: {
+        errorId?: string;
+    } & ErrorStartEvent): void;
+    /**
+     * Sends an error end event for this session
+     * @param args - Error end details including the error ID
+     * @internal
+     */
+    sendErrorEnd(args: {
+        errorId: string;
+    } & ErrorEndEvent): void;
+    /**
+     * Sends a metadata event for this session
+     * @param metaEvent - Metadata to send
+     * @internal
+     */
+    sendMetaEvent(metaEvent: MetaEvent): void;
+    /**
+     * Starts a new exchange in this session
+     *
+     * Each exchange is a request-response cycle. Use `sendMessageWithContentPart`
+     * on the returned {@link ExchangeStream} to send a user message, or
+     * `startMessage` for fine-grained control.
+     *
+     * @param args - Optional exchange start options
+     * @returns The exchange stream for sending messages
+     *
+     * @example Multi-exchange conversation
+     * ```typescript
+     * const session = conversation.startSession();
+     *
+     * // Listen for all assistant responses
+     * session.onExchangeStart((exchange) => {
+     *   exchange.onMessageCompleted((completed) => {
+     *     if (completed.role === MessageRole.Assistant) {
+     *       for (const part of completed.contentParts) {
+     *         console.log('Assistant:', part.data);
+     *       }
+     *     }
+     *   });
+     * });
+     *
+     * // Wait for session to be ready before starting exchanges
+     * session.onSessionStarted(async () => {
+     *   // Send first user message
+     *   const exchange1 = session.startExchange();
+     *   await exchange1.sendMessageWithContentPart({
+     *     data: 'What is the weather today?',
+     *     role: MessageRole.User
+     *   });
+     *
+     *   // Send follow-up in a new exchange
+     *   const exchange2 = session.startExchange();
+     *   await exchange2.sendMessageWithContentPart({
+     *     data: 'And tomorrow?',
+     *     role: MessageRole.User
+     *   });
+     * });
+     * ```
+     */
+    startExchange(args?: {
+        exchangeId?: string;
+    } & ExchangeStartEvent): ExchangeStream;
+    /**
+     * Iterator over all active exchanges in this session
+     */
+    readonly exchanges: Iterable<ExchangeStream>;
+    /**
+     * Retrieves an exchange by ID
+     * @param exchangeId - The exchange ID to look up
+     * @returns The exchange stream, or undefined if not found
+     */
+    getExchange(exchangeId: string): ExchangeStream | undefined;
+    /**
+     * Starts an async tool call at the session level
+     * @param args - Tool call start options including tool name
+     * @returns The async tool call stream for managing the lifecycle
+     * @internal
+     */
+    startAsyncToolCall(args: {
+        toolCallId?: string;
+    } & ToolCallStartEvent): AsyncToolCallStream;
+    /**
+     * Registers a handler for async tool call start events
+     * @param cb - Callback receiving each new async tool call
+     * @returns Cleanup function to remove the handler
+     * @internal
+     */
+    onAsyncToolCallStart(cb: (asyncToolCall: AsyncToolCallStream) => void): () => void;
+    /**
+     * Iterator over all active async tool calls in this session
+     * @internal
+     */
+    readonly asyncToolCalls: Iterable<AsyncToolCallStream>;
+    /**
+     * Retrieves an async tool call by ID
+     * @param toolCallId - The tool call ID to look up
+     * @returns The async tool call stream, or undefined if not found
+     * @internal
+     */
+    getAsyncToolCall(toolCallId: string): AsyncToolCallStream | undefined;
+    /**
+     * Starts an async input stream at the session level
+     * @param args - Stream start options including MIME type
+     * @returns The async input stream for sending data
+     * @internal
+     */
+    startAsyncInputStream(args: {
+        streamId?: string;
+    } & AsyncInputStreamStartEvent): AsyncInputStream;
+    /**
+     * Registers a handler for async input stream start events
+     * @param cb - Callback receiving each new input stream
+     * @returns Cleanup function to remove the handler
+     * @internal
+     */
+    onInputStreamStart(cb: (inputStream: AsyncInputStream) => void): () => void;
+    /**
+     * Iterator over all active async input streams in this session
+     * @internal
+     */
+    readonly asyncInputStreams: Iterable<AsyncInputStream>;
+    /**
+     * Retrieves an async input stream by ID
+     * @param streamId - The stream ID to look up
+     * @returns The async input stream, or undefined if not found
+     * @internal
+     */
+    getAsyncInputStream(streamId: string): AsyncInputStream | undefined;
+    /**
+     * Emits a raw conversation event
+     * @param conversationEvent - The event to emit (conversationId is added automatically)
+     * @internal
+     */
+    emit(conversationEvent: Omit<ConversationEvent, 'conversationId'>): void;
+    /**
+     * Registers a handler for error start events from any nested helper
+     *
+     * Unlike `onErrorStart` which only catches errors at the session level,
+     * this handler receives errors from all nested helpers (exchanges, messages,
+     * content parts, tool calls, etc.).
+     *
+     * @param cb - Callback receiving the error event with its source
+     * @returns Cleanup function to remove the handler
+     * @internal
+     */
+    onAnyErrorStart(cb: (errorStart: {
+        source: unknown;
+        errorId: string;
+    } & ErrorStartEvent) => void): () => void;
+    /**
+     * Registers a handler for error end events from any nested helper
+     *
+     * Unlike `onErrorEnd` which only catches errors at the session level,
+     * this handler receives error end events from all nested helpers.
+     *
+     * @param cb - Callback receiving the error end event with its source
+     * @returns Cleanup function to remove the handler
+     * @internal
+     */
+    onAnyErrorEnd(cb: (errorEnd: {
+        source: unknown;
+        errorId: string;
+    } & ErrorEndEvent) => void): () => void;
+    /**
+     * Replays persisted exchanges into this session
+     *
+     * Used to restore session state from previously saved exchange data.
+     *
+     * @param exchanges - The exchange data to replay
+     * @internal
+     */
+    replay(exchanges: Exchange[]): void;
+    /**
+     * Returns a string representation of this session
+     * @internal
+     */
+    toString(): string;
+}
+
+/**
+ * Types for Exchange Service
+ */
+
+/**
+ * Response type for Exchange with MessageGetResponse instead of raw Message
+ */
+interface ExchangeGetResponse extends Omit<Exchange, 'messages'> {
+    messages: MessageGetResponse[];
+}
+/**
+ * Response type for Message with ContentPartGetResponse
+ */
+interface MessageGetResponse extends Omit<Message, 'contentParts'> {
+    contentParts?: ContentPartGetResponse[];
+}
+/**
+ * Response interface for ContentPart with convenience methods for accessing data.
+ *
+ * Provides helper properties and methods to determine if content is stored
+ * inline or externally, and to retrieve the data accordingly.
+ *
+ * @example
+ * ```typescript
+ * const contentPart = message.contentParts[0];
+ *
+ * // Check storage type
+ * if (contentPart.isDataInline) {
+ *   const data = await contentPart.getData(); // Returns string
+ * } else if (contentPart.isDataExternal) {
+ *   const response = await contentPart.getData(); // Returns fetch Response
+ * }
+ * ```
+ */
+interface ContentPartGetResponse extends ContentPart {
+    /** Returns true if data is stored inline (as a string value) */
+    readonly isDataInline: boolean;
+    /** Returns true if data is stored externally (as a URI reference) */
+    readonly isDataExternal: boolean;
+    /**
+     * Retrieves the content data.
+     * @returns For inline data: the string content. For external data: a fetch Response.
+     */
+    getData(): Promise<string | Response>;
+}
+type ExchangeGetAllOptions = PaginationOptions & {
+    /** Sort order for exchanges */
+    exchangeSort?: SortOrder;
+    /** Sort order for messages within each exchange */
+    messageSort?: SortOrder;
+};
+interface ExchangeGetByIdOptions {
+    /** Sort order for messages within the exchange */
+    messageSort?: SortOrder;
+}
+interface CreateFeedbackOptions {
+    /** Rating for the exchange ('positive' or 'negative') */
+    rating: FeedbackRating;
+    /** Optional text comment for the feedback */
+    comment?: string;
+}
+interface FeedbackCreateResponse {
+}
+
+/**
+ * Exchange Service Model
+ */
+
+/**
+ * Service for retrieving exchanges and managing feedback within a {@link ConversationServiceModel | Conversation}
+ *
+ * An exchange represents a single request-response cycle — typically one user
+ * question and the agent's reply. Each exchange response includes its
+ * {@link MessageServiceModel | Messages}, making this the primary way to retrieve
+ * conversation history. For real-time streaming of exchanges, see {@link ExchangeStream}.
+ *
+ * ### Usage
+ *
+ * Prerequisites: Initialize the SDK first - see [Getting Started](/uipath-typescript/getting-started/#import-initialize)
+ *
+ * ```typescript
+ * import { Exchanges } from '@uipath/uipath-typescript/conversational-agent';
+ *
+ * const exchanges = new Exchanges(sdk);
+ * const conversationExchanges = await exchanges.getAll(conversationId);
+ * ```
+ */
+interface ExchangeServiceModel {
+    /**
+     * Gets all exchanges for a conversation with optional filtering and pagination
+     *
+     * @param conversationId - The conversation ID to get exchanges for
+     * @param options - Options for querying exchanges including optional pagination parameters
+     * @returns Promise resolving to either an array of exchanges {@link NonPaginatedResponse}<{@link ExchangeGetResponse}> or a {@link PaginatedResponse}<{@link ExchangeGetResponse}> when pagination options are used
+     * @example
+     * ```typescript
+     * // Get all exchanges (non-paginated)
+     * const conversationExchanges = await exchanges.getAll(conversationId);
+     *
+     * // First page with pagination
+     * const firstPageOfExchanges = await exchanges.getAll(conversationId, { pageSize: 10 });
+     *
+     * // Navigate using cursor
+     * if (firstPageOfExchanges.hasNextPage) {
+     *   const nextPageOfExchanges = await exchanges.getAll(conversationId, {
+     *     cursor: firstPageOfExchanges.nextCursor
+     *   });
+     * }
+     * ```
+     */
+    getAll<T extends ExchangeGetAllOptions = ExchangeGetAllOptions>(conversationId: string, options?: T): Promise<T extends HasPaginationOptions<T> ? PaginatedResponse<ExchangeGetResponse> : NonPaginatedResponse<ExchangeGetResponse>>;
+    /**
+     * Gets an exchange by ID with its messages
+     *
+     * @param conversationId - The conversation containing the exchange
+     * @param exchangeId - The exchange ID to retrieve
+     * @param options - Optional parameters for message sorting
+     * @returns Promise resolving to {@link ExchangeGetResponse}
+     * @example
+     * ```typescript
+     * const exchange = await exchanges.getById(conversationId, exchangeId);
+     *
+     * // Access messages
+     * for (const message of exchange.messages) {
+     *   console.log(message.role, message.contentParts);
+     * }
+     * ```
+     */
+    getById(conversationId: string, exchangeId: string, options?: ExchangeGetByIdOptions): Promise<ExchangeGetResponse>;
+    /**
+     * Creates feedback for an exchange
+     *
+     * @param conversationId - The conversation containing the exchange
+     * @param exchangeId - The exchange to provide feedback for
+     * @param options - Feedback data including rating and optional comment
+     * @returns Promise resolving to the feedback creation response
+     * {@link FeedbackCreateResponse}
+     * @example
+     * ```typescript
+     * await exchanges.createFeedback(
+     *   conversationId,
+     *   exchangeId,
+     *   { rating: FeedbackRating.Positive, comment: 'Very helpful!' }
+     * );
+     * ```
+     */
+    createFeedback(conversationId: string, exchangeId: string, options: CreateFeedbackOptions): Promise<FeedbackCreateResponse>;
+}
+/**
+ * Scoped exchange service for a specific conversation.
+ * Auto-fills conversationId from the conversation.
+ */
+interface ConversationExchangeServiceModel {
+    /**
+     * Gets all exchanges for this conversation with optional filtering and pagination
+     *
+     * @param options - Options for querying exchanges including optional pagination parameters
+     * @returns Promise resolving to either an array of exchanges or a paginated response
+     *
+     * @example
+     * ```typescript
+     * const conversation = await conversationalAgent.conversations.getById(conversationId);
+     *
+     * // Get all exchanges
+     * const allExchanges = await conversation.exchanges.getAll();
+     *
+     * // With pagination
+     * const firstPage = await conversation.exchanges.getAll({ pageSize: 10 });
+     * if (firstPage.hasNextPage) {
+     *   const nextPage = await conversation.exchanges.getAll({ cursor: firstPage.nextCursor });
+     * }
+     * ```
+     */
+    getAll<T extends ExchangeGetAllOptions = ExchangeGetAllOptions>(options?: T): Promise<T extends HasPaginationOptions<T> ? PaginatedResponse<ExchangeGetResponse> : NonPaginatedResponse<ExchangeGetResponse>>;
+    /**
+     * Gets an exchange by ID with its messages
+     *
+     * @param exchangeId - The exchange ID to retrieve
+     * @param options - Optional parameters for message sorting
+     * @returns Promise resolving to the exchange with messages
+     *
+     * @example
+     * ```typescript
+     * const exchange = await conversation.exchanges.getById(exchangeId);
+     * for (const message of exchange.messages) {
+     *   console.log(message.role, message.contentParts);
+     * }
+     * ```
+     */
+    getById(exchangeId: string, options?: ExchangeGetByIdOptions): Promise<ExchangeGetResponse>;
+    /**
+     * Creates feedback for an exchange
+     *
+     * @param exchangeId - The exchange to provide feedback for
+     * @param options - Feedback data including rating and optional comment
+     * @returns Promise resolving to the feedback creation response
+     *
+     * @example
+     * ```typescript
+     * await conversation.exchanges.createFeedback(exchangeId, {
+     *   rating: FeedbackRating.Positive,
+     *   comment: 'Very helpful!'
+     * });
+     * ```
+     */
+    createFeedback(exchangeId: string, options: CreateFeedbackOptions): Promise<FeedbackCreateResponse>;
+}
+
+/**
+ * WebSocket Types - Common types for WebSocket infrastructure
+ */
+/**
+ * Connection status for WebSocket clients
+ */
+declare enum ConnectionStatus {
+    Disconnected = "Disconnected",
+    Connecting = "Connecting",
+    Connected = "Connected"
+}
+/**
+ * Handler for connection status changes
+ */
+type ConnectionStatusChangedHandler = (status: ConnectionStatus, error: Error | null) => void;
+/**
+ * Log levels for WebSocket debugging
+ */
+declare enum LogLevel {
+    Debug = "debug",
+    Info = "info",
+    Warn = "warn",
+    Error = "error"
+}
+
+/**
+ * Conversation Service Model
+ *
+ * This interface defines the HTTP CRUD operations for conversations
+ * and real-time WebSocket session management.
+ */
+
+/**
+ * Methods interface for session operations.
+ * This allows the conversation object to access session methods without
+ * depending on the full ConversationService implementation.
+ */
+interface ConversationSessionMethods {
+    /**
+     * Starts a real-time chat session for a conversation
+     */
+    startSession(conversationId: string, options?: ConversationSessionOptions): SessionStream;
+    /**
+     * Gets an active session for a conversation
+     */
+    getSession(conversationId: string): SessionStream | undefined;
+    /**
+     * Ends an active session for a conversation
+     */
+    endSession(conversationId: string): void;
+}
+/**
+ * Service for creating and managing conversations with UiPath Conversational Agents
+ *
+ * A conversation is a long-lived interaction with a specific agent with shared context.
+ * It persists across sessions and can be resumed at any time. To retrieve the
+ * conversation history, use the {@link ExchangeServiceModel | Exchanges} service.
+ * For real-time chat, see {@link SessionStream | Session}.
+ *
+ * ### Usage
+ *
+ * Prerequisites: Initialize the SDK first - see [Getting Started](/uipath-typescript/getting-started/#import-initialize)
+ *
+ * ```typescript
+ * import { ConversationalAgent } from '@uipath/uipath-typescript/conversational-agent';
+ *
+ * const conversationalAgent = new ConversationalAgent(sdk);
+ *
+ * // Access conversations through the main service
+ * const conversation = await conversationalAgent.conversations.create(agentId, folderId);
+ *
+ * // Or through agent objects (agentId/folderId auto-filled)
+ * const agents = await conversationalAgent.getAll();
+ * const agentConversation = await agents[0].conversations.create({ label: 'My Chat' });
+ * ```
+ */
+interface ConversationServiceModel {
+    /**
+     * Creates a new conversation
+     *
+     * The returned conversation has bound methods for lifecycle management:
+     * `update()`, `delete()`, and `startSession()`.
+     *
+     * @param agentId - The agent ID to create the conversation for
+     * @param folderId - The folder ID containing the agent
+     * @param options - Optional settings for the conversation
+     * @returns Promise resolving to {@link ConversationCreateResponse} with bound methods
+     *
+     * @example
+     * ```typescript
+     * const conversation = await conversationalAgent.conversations.create(
+     *   agentId,
+     *   folderId,
+     *   { label: 'Customer Support Session' }
+     * );
+     *
+     * // Update the conversation
+     * await conversation.update({ label: 'Renamed Chat' });
+     *
+     * // Start a real-time session
+     * const session = conversation.startSession();
+     *
+     * // Delete the conversation
+     * await conversation.delete();
+     * ```
+     */
+    create(agentId: number, folderId: number, options?: ConversationCreateOptions): Promise<ConversationCreateResponse>;
+    /**
+     * Gets all conversations with optional filtering and pagination
+     *
+     * @param options - Options for querying conversations including optional pagination parameters
+     * @returns Promise resolving to either an array of conversations NonPaginatedResponse<ConversationGetResponse> or a PaginatedResponse<ConversationGetResponse> when pagination options are used
+     *
+     * @example Basic usage - get all conversations
+     * ```typescript
+     * const allConversations = await conversationalAgent.conversations.getAll();
+     *
+     * for (const conversation of allConversations.items) {
+     *   console.log(`${conversation.label} - created: ${conversation.createdTime}`);
+     * }
+     * ```
+     *
+     * @example With pagination
+     * ```typescript
+     * // First page
+     * const firstPage = await conversationalAgent.conversations.getAll({ pageSize: 10 });
+     *
+     * // Navigate using cursor
+     * if (firstPage.hasNextPage) {
+     *   const nextPage = await conversationalAgent.conversations.getAll({
+     *     cursor: firstPage.nextCursor
+     *   });
+     * }
+     * ```
+     *
+     * @example Sorted with limit
+     * ```typescript
+     * const result = await conversationalAgent.conversations.getAll({
+     *   sort: SortOrder.Descending,
+     *   pageSize: 20
+     * });
+     * ```
+     */
+    getAll<T extends ConversationGetAllOptions = ConversationGetAllOptions>(options?: T): Promise<T extends HasPaginationOptions<T> ? PaginatedResponse<ConversationGetResponse> : NonPaginatedResponse<ConversationGetResponse>>;
+    /**
+     * Gets a conversation by ID
+     *
+     * The returned conversation has bound methods for lifecycle management:
+     * `update()`, `delete()`, and `startSession()`.
+     *
+     * @param id - The conversation ID to retrieve
+     * @returns Promise resolving to {@link ConversationGetResponse} with bound methods
+     *
+     * @example Resume with a real-time session
+     * ```typescript
+     * const conversation = await conversationalAgent.conversations.getById(conversationId);
+     * const session = conversation.startSession();
+     * ```
+     *
+     * @example
+     * ```typescript
+     * //Retrieve conversation history
+     * const conversation = await conversationalAgent.conversations.getById(conversationId);
+     * const allExchanges = await conversation.exchanges.getAll();
+     * for (const exchange of allExchanges.items) {
+     *   for (const message of exchange.messages) {
+     *     console.log(`${message.role}: ${message.contentParts.map(p => p.data).join('')}`);
+     *   }
+     * }
+     * ```
+     */
+    getById(id: string): Promise<ConversationGetResponse>;
+    /**
+     * Updates a conversation by ID
+     *
+     * @param id - The conversation ID to update
+     * @param options - Fields to update
+     * @returns Promise resolving to {@link ConversationGetResponse} with bound methods
+     * @example
+     * ```typescript
+     * const updatedConversation = await conversationalAgent.conversations.updateById(conversationId, {
+     *   label: 'Updated Name'
+     * });
+     * ```
+     */
+    updateById(id: string, options: ConversationUpdateOptions): Promise<ConversationUpdateResponse>;
+    /**
+     * Deletes a conversation by ID
+     *
+     * @param id - The conversation ID to delete
+     * @returns Promise resolving to {@link ConversationDeleteResponse}
+     * @example
+     * ```typescript
+     * await conversationalAgent.conversations.deleteById(conversationId);
+     * ```
+     */
+    deleteById(id: string): Promise<ConversationDeleteResponse>;
+    /**
+     * Uploads a file attachment to a conversation
+     *
+     * @param id - The ID of the conversation to attach the file to
+     * @param file - The file to upload
+     * @returns Promise resolving to attachment metadata with URI
+     * {@link ConversationAttachmentUploadResponse}
+     *
+     * @example
+     * ```typescript
+     * const attachment = await conversationalAgent.conversations.uploadAttachment(conversationId, file);
+     * console.log(`Uploaded: ${attachment.uri}`);
+     * ```
+     */
+    uploadAttachment(id: string, file: File): Promise<ConversationAttachmentUploadResponse>;
+    /**
+     * Starts a real-time chat session for a conversation
+     *
+     * Creates a WebSocket session and returns a SessionStream for sending
+     * and receiving messages in real-time.
+     *
+     * @param conversationId - The conversation ID to start the session for
+     * @param options - Optional session configuration
+     * @returns SessionStream for managing the session
+     *
+     * @example
+     * ```typescript
+     * const session = conversationalAgent.conversations.startSession(conversation.id);
+     *
+     * // Listen for responses using helper methods
+     * session.onExchangeStart((exchange) => {
+     *   exchange.onMessageStart((message) => {
+     *     // Use message.isAssistant to filter AI responses
+     *     if (message.isAssistant) {
+     *       message.onContentPartStart((part) => {
+     *         // Use part.isMarkdown to handle text content
+     *         if (part.isMarkdown) {
+     *           part.onChunk((chunk) => console.log(chunk.data));
+     *         }
+     *       });
+     *     }
+     *   });
+     * });
+     *
+     * // Wait for session to be ready, then send a message
+     * session.onSessionStarted(() => {
+     *   const exchange = session.startExchange();
+     *   exchange.sendMessageWithContentPart({ data: 'Hello!' });
+     * });
+     *
+     * // End the session when done
+     * conversationalAgent.conversations.endSession(conversation.id);
+     * ```
+     */
+    startSession(conversationId: string, options?: ConversationSessionOptions): SessionStream;
+    /**
+     * Retrieves an active session by conversation ID
+     *
+     * @param conversationId - The conversation ID to get the session for
+     * @returns The session helper if active, undefined otherwise
+     *
+     * @example
+     * ```typescript
+     * const session = conversationalAgent.conversations.getSession(conversationId);
+     * if (session) {
+     *   // Session already started — safe to send exchanges directly
+     *   const exchange = session.startExchange();
+     *   exchange.sendMessageWithContentPart({ data: 'Hello!' });
+     * }
+     * ```
+     */
+    getSession(conversationId: string): SessionStream | undefined;
+    /**
+     * Ends an active session for a conversation
+     *
+     * Sends a session end event and releases the socket for the conversation.
+     * If no active session exists for the given conversation, this is a no-op.
+     *
+     * @param conversationId - The conversation ID to end the session for
+     *
+     * @example
+     * ```typescript
+     * // End session for a specific conversation
+     * conversationalAgent.conversations.endSession(conversationId);
+     * ```
+     */
+    endSession(conversationId: string): void;
+    /**
+     * Iterator over all active sessions
+     * @internal
+     */
+    readonly sessions: Iterable<SessionStream>;
+    /**
+     * Current connection status
+     * @internal
+     */
+    readonly connectionStatus: ConnectionStatus;
+    /**
+     * Whether WebSocket is connected
+     * @internal
+     */
+    readonly isConnected: boolean;
+    /**
+     * Current connection error, if any
+     * @internal
+     */
+    readonly connectionError: Error | null;
+    /**
+     * Registers a handler for connection status changes
+     * @internal
+     */
+    onConnectionStatusChanged(handler: ConnectionStatusChangedHandler): () => void;
+}
+/**
+ * Methods interface that will be added to conversation objects
+ */
+interface ConversationMethods {
+    /** Scoped exchange operations for this conversation */
+    readonly exchanges: ConversationExchangeServiceModel;
+    /**
+     * Updates this conversation
+     *
+     * @param options - Fields to update
+     * @returns Promise resolving to the updated conversation
+     */
+    update(options: ConversationUpdateOptions): Promise<ConversationUpdateResponse>;
+    /**
+     * Deletes this conversation
+     *
+     * @returns Promise resolving to the deletion response
+     */
+    delete(): Promise<ConversationDeleteResponse>;
+    /**
+     * Starts a real-time chat session for this conversation
+     *
+     * Creates a WebSocket session and returns a SessionStream for sending
+     * and receiving messages in real-time.
+     *
+     * @param options - Optional session options
+     * @returns SessionStream for managing the session
+     *
+     * @example
+     * ```typescript
+     * const conversation = await conversationalAgent.conversations.create(agentId, folderId);
+     *
+     * // Start a real-time session
+     * const session = conversation.startSession();
+     *
+     * // Listen for responses using helper methods
+     * session.onExchangeStart((exchange) => {
+     *   exchange.onMessageStart((message) => {
+     *     // Filter for assistant messages
+     *     if (message.isAssistant) {
+     *       message.onContentPartStart((part) => {
+     *         // Handle text content
+     *         if (part.isMarkdown) {
+     *           part.onChunk((chunk) => console.log(chunk.data));
+     *         }
+     *       });
+     *     }
+     *   });
+     * });
+     *
+     * // Wait for session to be ready, then send a message
+     * session.onSessionStarted(() => {
+     *   const exchange = session.startExchange();
+     *   exchange.sendMessageWithContentPart({ data: 'Hello!' });
+     * });
+     * ```
+     */
+    startSession(options?: ConversationSessionOptions): SessionStream;
+    /**
+     * Gets the active session for this conversation
+     *
+     * @returns The session helper if active, undefined otherwise
+     *
+     * @example
+     * ```typescript
+     * const session = conversation.getSession();
+     * if (session) {
+     *   // Session already started — safe to send exchanges directly
+     *   const exchange = session.startExchange();
+     *   exchange.sendMessageWithContentPart({ data: 'Hello!' });
+     * }
+     * ```
+     */
+    getSession(): SessionStream | undefined;
+    /**
+     * Ends the active session for this conversation
+     *
+     * Sends a session end event and cleans up the session resources.
+     *
+     * @example
+     * ```typescript
+     * // End the session when done
+     * conversation.endSession();
+     * ```
+     */
+    endSession(): void;
+    /**
+     * Uploads a file attachment to this conversation
+     *
+     * @param file - The file to upload
+     * @returns Promise resolving to attachment metadata with URI
+     * {@link ConversationAttachmentUploadResponse}
+     *
+     * @example
+     * ```typescript
+     * const attachment = await conversation.uploadAttachment(file);
+     * console.log(`Uploaded: ${attachment.uri}`);
+     * ```
+     */
+    uploadAttachment(file: File): Promise<ConversationAttachmentUploadResponse>;
+}
+/**
+ * Conversation combining {@link RawConversationGetResponse} metadata with {@link ConversationMethods} for lifecycle management
+ */
+type ConversationGetResponse = RawConversationGetResponse & ConversationMethods;
+/**
+ * Creates an actionable conversation by combining API conversation data with operational methods.
+ *
+ * @param conversationData - The conversation data from API
+ * @param service - The conversation service instance
+ * @param sessionMethods - Optional session methods for WebSocket session operations
+ * @param exchangeService - Optional exchange service for scoped exchange methods
+ * @returns A conversation object with added methods
+ */
+declare function createConversationWithMethods(conversationData: RawConversationGetResponse, service: ConversationServiceModel, sessionMethods?: ConversationSessionMethods, exchangeService?: ExchangeServiceModel): ConversationGetResponse;
+
+/**
+ * Types for Conversation Service
+ */
+
+/**
+ * Options for starting a session on a conversation object.
+ * Unlike SessionStartEventOptions, conversationId is not needed since it's implicit from the conversation.
+ */
+interface ConversationSessionOptions {
+    /**
+     * When set, causes events emitted to also be dispatched to event handlers.
+     * This option is useful when the event helper objects are bound to UI components
+     * as it allows a single code path for rendering both user and assistant messages.
+     */
+    echo?: boolean;
+    /**
+     * Sets the log level for WebSocket session debugging.
+     * When set, enables logging at the specified level for the underlying WebSocket connection.
+     *
+     * @example
+     * ```typescript
+     * import { LogLevel } from '@uipath/uipath-typescript/conversational-agent';
+     *
+     * const session = conversation.startSession({ logLevel: LogLevel.Debug });
+     * ```
+     */
+    logLevel?: LogLevel;
+}
+/** Response for creating a conversation (includes methods) */
+type ConversationCreateResponse = ConversationGetResponse;
+/** Response for updating a conversation (includes methods) */
+type ConversationUpdateResponse = ConversationGetResponse;
+/** Response for deleting a conversation (raw data, no methods needed) */
+type ConversationDeleteResponse = RawConversationGetResponse;
+interface ConversationCreateOptions {
+    /** Human-readable label for the conversation (max 100 chars) */
+    label?: string;
+    /** Whether the label should be auto-generated and updated after exchanges */
+    autogenerateLabel?: boolean;
+    /** Trace identifier for distributed tracing */
+    traceId?: string;
+    /** Optional configuration for job start behavior */
+    jobStartOverrides?: ConversationJobStartOverrides;
+}
+interface ConversationUpdateOptions {
+    /** Human-readable label for the conversation */
+    label?: string;
+    /** Whether the label should be auto-generated and updated after exchanges */
+    autogenerateLabel?: boolean;
+    /** The key of the current/latest job serving the conversation */
+    jobKey?: string;
+    /** Whether the conversation's job is running locally */
+    isLocalJobExecution?: boolean;
+}
+type ConversationGetAllOptions = PaginationOptions & {
+    /** Sort order for conversations */
+    sort?: SortOrder;
+};
+/**
+ * File upload access details for uploading file content to blob storage
+ */
+interface FileUploadAccess {
+    /** URL to upload the file to */
+    url: string;
+    /** HTTP verb to use (e.g., 'PUT') */
+    verb: string;
+    /** Headers to include in the upload request */
+    headers: {
+        keys: string[];
+        values: string[];
+    };
+    /** Whether authentication is required for the upload */
+    requiresAuth?: boolean;
+}
+/**
+ * Response for creating a file attachment entry
+ *
+ * Contains the attachment URI and upload access details for uploading
+ * the file content to blob storage.
+ */
+interface ConversationAttachmentCreateResponse {
+    /** URI to reference this attachment in messages */
+    uri: string;
+    /** File name */
+    name: string;
+    /** Details for uploading the file content */
+    fileUploadAccess: FileUploadAccess;
+}
+/**
+ * Response for uploading an attachment (after file content is uploaded)
+ */
+interface ConversationAttachmentUploadResponse {
+    /** URI to reference this attachment in messages */
+    uri: string;
+    /** File name */
+    name: string;
+    /** MIME type of the uploaded file */
+    mimeType: string;
+}
+
+/**
+ * Message Service Model
+ */
+
+/**
+ * Service for retrieving individual messages within an {@link ExchangeServiceModel | Exchange}
+ *
+ * A message is a single turn from a user, assistant, or system. Each message includes
+ * a role, contentParts (text, audio, images), toolCalls, and interrupts.
+ * Messages are also returned as part of exchange responses — use this service
+ * when you need to fetch a specific message by ID or retrieve external content parts.
+ * For real-time streaming of messages, see {@link MessageStream}.
+ *
+ * ### Usage
+ *
+ * Prerequisites: Initialize the SDK first - see [Getting Started](/uipath-typescript/getting-started/#import-initialize)
+ *
+ * ```typescript
+ * import { Messages } from '@uipath/uipath-typescript/conversational-agent';
+ *
+ * const message = new Messages(sdk);
+ * const messageDetails = await message.getById(conversationId, exchangeId, messageId);
+ * ```
+ */
+interface MessageServiceModel {
+    /**
+     * Gets a message by ID
+     *
+     * Returns the message including its content parts, tool calls, and interrupts.
+     *
+     * @param conversationId - The conversation containing the message
+     * @param exchangeId - The exchange containing the message
+     * @param messageId - The message ID to retrieve
+     * @returns Promise resolving to {@link MessageGetResponse}
+     * @example
+     * ```typescript
+     * const message = await messages.getById(conversationId, exchangeId, messageId);
+     *
+     * console.log(message.role);
+     * console.log(message.contentParts);
+     * console.log(message.toolCalls);
+     * ```
+     */
+    getById(conversationId: string, exchangeId: string, messageId: string): Promise<MessageGetResponse>;
+    /**
+     * Gets an external content part by ID
+     *
+     * @param conversationId - The conversation containing the content
+     * @param exchangeId - The exchange containing the content
+     * @param messageId - The message containing the content part
+     * @param contentPartId - The content part ID to retrieve
+     * @returns Promise resolving to {@link ContentPartGetResponse}
+     * @example
+     * ```typescript
+     * const contentPart = await messages.getContentPartById(
+     *   conversationId,
+     *   exchangeId,
+     *   messageId,
+     *   contentPartId
+     * );
+     * ```
+     */
+    getContentPartById(conversationId: string, exchangeId: string, messageId: string, contentPartId: string): Promise<ContentPartGetResponse>;
+}
+
+/**
+ * Types for Agent Service
+ */
+/**
+ * Starting prompt configuration for an agent
+ */
+interface AgentStartingPrompt {
+    /** The prompt text displayed to the user */
+    displayPrompt: string;
+    /** The actual prompt sent when selected */
+    actualPrompt: string;
+    /** Unique identifier for the prompt */
+    id: string;
+}
+/**
+ * Agent appearance configuration
+ */
+interface AgentAppearance {
+    /** Welcome title displayed to users */
+    welcomeTitle?: string;
+    /** Welcome description displayed to users */
+    welcomeDescription?: string;
+    /** Starting prompts for users to choose from */
+    startingPrompts?: AgentStartingPrompt[];
+}
+/**
+ * Raw API response for getting all agents
+ */
+interface RawAgentGetResponse {
+    /** Unique ID of the agent */
+    id: number;
+    /** Display name of the agent */
+    name: string;
+    /** Agent description */
+    description: string;
+    /** Process version */
+    processVersion: string;
+    /** Process key identifier */
+    processKey: string;
+    /** Folder ID */
+    folderId: number;
+    /** Feed ID */
+    feedId: string;
+    /** Creation timestamp */
+    createdTime?: string;
+}
+/**
+ * Raw API response for getting a single agent by ID - includes appearance configuration
+ */
+interface RawAgentGetByIdResponse extends RawAgentGetResponse {
+    /** Agent appearance configuration */
+    appearance?: AgentAppearance;
+}
+
+/**
+ * Agent Service Models
+ *
+ * Provides fluent API for agent objects returned from getAll() and getById().
+ */
+
+/**
+ * Options for creating a conversation from an agent
+ */
+type AgentCreateConversationOptions = ConversationCreateOptions;
+/**
+ * Scoped conversation service for a specific agent.
+ * Auto-fills agentId and folderId from the agent.
+ */
+interface AgentConversationServiceModel {
+    /**
+     * Creates a conversation for this agent
+     *
+     * @param options - Optional conversation options (label, etc.)
+     * @returns Promise resolving to the created conversation with methods
+     *
+     * @example
+     * ```typescript
+     * const agent = (await conversationalAgent.getAll())[0];
+     * const conversation = await agent.conversations.create({ label: 'My Chat' });
+     * const session = conversation.startSession();
+     * ```
+     */
+    create(options?: AgentCreateConversationOptions): Promise<ConversationCreateResponse>;
+}
+/**
+ * Methods added to agent objects
+ */
+interface AgentMethods {
+    /** Scoped conversation operations for this agent */
+    readonly conversations: AgentConversationServiceModel;
+    /** Current WebSocket connection status */
+    get connectionStatus(): ConnectionStatus;
+    /** Whether the WebSocket connection is currently active */
+    get isConnected(): boolean;
+    /** Current connection error, or `null` if none */
+    get connectionError(): Error | null;
+}
+/**
+ * Agent combining {@link RawAgentGetResponse} metadata with {@link AgentMethods} for conversation and connection management
+ */
+type AgentGetResponse = RawAgentGetResponse & AgentMethods;
+/**
+ * Agent combining {@link RawAgentGetByIdResponse} metadata with {@link AgentMethods} for conversation and connection management
+ */
+type AgentGetByIdResponse = RawAgentGetByIdResponse & AgentMethods;
+declare function createAgentWithMethods<T extends RawAgentGetResponse>(agentData: T, conversationService: ConversationServiceModel): T & AgentMethods;
+
+/**
+ * Constants for Agent Service
+ */
+/**
+ * Maps fields for Agent entities to ensure consistent SDK naming
+ */
+declare const AgentMap: {
+    [key: string]: string;
+};
+
+/**
+ * Types for User Service
+ */
+/**
+ * Response for getting user settings
+ *
+ * Contains profile and context information that is passed to the agent
+ * for all conversations to provide user context.
+ *
+ * @example
+ * ```typescript
+ * const userSettings = await conversationalAgentService.user.getSettings();
+ * console.log(userSettings.name, userSettings.email);
+ * ```
+ */
+interface UserSettingsGetResponse {
+    /** Unique identifier of the user (UUID) */
+    userId: string;
+    /** Name of the user (max 100 chars) */
+    name: string | null;
+    /** Email address (max 255 chars, must be valid email) */
+    email: string | null;
+    /** Role of the user (max 100 chars) */
+    role: string | null;
+    /** Department (max 100 chars) */
+    department: string | null;
+    /** Company (max 100 chars) */
+    company: string | null;
+    /** Country (max 100 chars) */
+    country: string | null;
+    /** Timezone (max 50 chars) */
+    timezone: string | null;
+    /** UTC timestamp of creation */
+    createdTime: string;
+    /** UTC timestamp of last update */
+    updatedTime: string;
+}
+/** Response for updating user settings */
+type UserSettingsUpdateResponse = UserSettingsGetResponse;
+/**
+ * Options for updating user settings
+ *
+ * All fields are optional - only send the fields you want to change.
+ * Set fields to `null` to explicitly clear them.
+ * Omitting fields means no change.
+ *
+ * @example
+ * ```typescript
+ * // Update specific fields
+ * await conversationalAgentService.user.updateSettings({
+ *   name: 'John Doe',
+ *   timezone: 'America/New_York'
+ * });
+ *
+ * // Clear a field by setting to null
+ * await conversationalAgentService.user.updateSettings({
+ *   department: null
+ * });
+ * ```
+ */
+interface UserSettingsUpdateOptions {
+    /** Name of the user (max 100 chars) */
+    name?: string | null;
+    /** Email address (max 255 chars, must be valid email) */
+    email?: string | null;
+    /** Role of the user (max 100 chars) */
+    role?: string | null;
+    /** Department (max 100 chars) */
+    department?: string | null;
+    /** Company (max 100 chars) */
+    company?: string | null;
+    /** Country (max 100 chars) */
+    country?: string | null;
+    /** Timezone (max 50 chars) */
+    timezone?: string | null;
+}
+
+/**
+ * Service for managing UiPath User Settings
+ *
+ * User settings are passed to the agent for all conversations
+ * to provide user context (name, email, role, timezone, etc.).
+ *
+ * @internal
+ */
+interface UserServiceModel {
+    /**
+     * Gets the current user's profile and context settings
+     *
+     * @returns Promise resolving to user settings object
+     * {@link UserSettingsGetResponse}
+     * @example
+     * ```typescript
+     * const userSettings = await userService.getSettings();
+     * console.log(userSettings.name);
+     * console.log(userSettings.email);
+     * ```
+     */
+    getSettings(): Promise<UserSettingsGetResponse>;
+    /**
+     * Updates the current user's profile and context settings
+     *
+     * @param options - Fields to update
+     * @returns Promise resolving to updated user settings
+     * {@link UserSettingsUpdateResponse}
+     * @example
+     * ```typescript
+     * const updatedUserSettings = await userService.updateSettings({
+     *   name: 'John Doe',
+     *   timezone: 'America/New_York'
+     * });
+     * ```
+     */
+    updateSettings(options: UserSettingsUpdateOptions): Promise<UserSettingsUpdateResponse>;
+}
+
+/**
+ * Constants for User Service
+ */
+/**
+ * Maps fields for User Settings entities to ensure consistent SDK naming
+ */
+declare const UserSettingsMap: {
+    [key: string]: string;
+};
+
+/**
+ * Types for Feature Flags
+ */
+/**
+ * Feature flags for conversational agent capabilities
+ *
+ * @internal
+ */
+type FeatureFlags = Record<string, unknown>;
+
+/**
+ * Service for managing UiPath Conversational Agents — AI-powered chat interfaces that enable
+ * natural language interactions with UiPath automation. Discover agents, create conversations,
+ * and stream real-time responses over WebSocket. [UiPath Conversational Agents Guide](https://docs.uipath.com/agents/automation-cloud/latest/user-guide/conversational-agents)
+ *
+ * Prerequisites: Initialize the SDK first - see [Getting Started](/uipath-typescript/getting-started/#import-initialize)
+ *
+ * ## How It Works
+ *
+ * ### Lifecycle
+ *
+ * ```mermaid
+ * graph TD
+ *     A["Agent"] -->|conversations.create| B["Conversation"]
+ *     B -->|startSession| C["Session"]
+ *     B -->|exchanges.getAll| F(["History"])
+ *     C -->|onSessionStarted| D["Ready"]
+ *     D -->|startExchange| E["Exchange"]
+ *     E -->|sendMessage| G["Message"]
+ * ```
+ *
+ * ### Real-Time Event Flow
+ *
+ * Once a session is started, events flow through a nested stream hierarchy:
+ *
+ * ```mermaid
+ * graph TD
+ *     S["SessionStream"]
+ *     S -->|onExchangeStart| E["ExchangeStream"]
+ *     S -->|onSessionEnd| SE(["session closed"])
+ *     E -->|onMessageStart| M["MessageStream"]
+ *     E -->|onExchangeEnd| EE(["exchange complete"])
+ *     M -->|onContentPartStart| CP["ContentPartStream"]
+ *     M -->|onToolCallStart| TC["ToolCallStream"]
+ *     M -->|onInterruptStart| IR(["awaiting approval"])
+ *     CP -->|onChunk| CH(["streaming data"])
+ *     TC -->|onToolCallEnd| TCE(["tool result"])
+ * ```
+ *
+ * ## Usage
+ *
+ * ```typescript
+ * import { ConversationalAgent } from '@uipath/uipath-typescript/conversational-agent';
+ *
+ * const conversationalAgent = new ConversationalAgent(sdk);
+ *
+ * // 1. Discover agents
+ * const agents = await conversationalAgent.getAll();
+ * const agent = agents[0];
+ *
+ * // 2. Create a conversation
+ * const conversation = await agent.conversations.create({ label: 'My Chat' });
+ *
+ * // 3. Start real-time session and listen for responses
+ * const session = conversation.startSession();
+ *
+ * session.onExchangeStart((exchange) => {
+ *   exchange.onMessageStart((message) => {
+ *     if (message.isAssistant) {
+ *       message.onContentPartStart((part) => {
+ *         if (part.isMarkdown) {
+ *           part.onChunk((chunk) => process.stdout.write(chunk.data ?? ''));
+ *         }
+ *       });
+ *     }
+ *   });
+ * });
+ *
+ * // 4. Wait for session to be ready, then send a message
+ * session.onSessionStarted(() => {
+ *   const exchange = session.startExchange();
+ *   exchange.sendMessageWithContentPart({ data: 'Hello!' });
+ * });
+ *
+ * // 5. End session when done
+ * conversation.endSession();
+ *
+ * // 6. Retrieve conversation history (offline)
+ * const exchanges = await conversation.exchanges.getAll();
+ * ```
+ */
+interface ConversationalAgentServiceModel {
+    /**
+     * Gets all available conversational agents
+     *
+     * @param folderId - Optional folder ID to filter agents
+     * @returns Promise resolving to an array of agents
+     * {@link AgentGetResponse}
+     *
+     * @example Basic usage
+     * ```typescript
+     * const agents = await conversationalAgent.getAll();
+     * const agent = agents[0];
+     *
+     * // Create conversation directly from agent (agentId and folderId are auto-filled)
+     * const conversation = await agent.conversations.create({ label: 'My Chat' });
+     * ```
+     *
+     * @example Filter agents by folder
+     * ```typescript
+     * const agents = await conversationalAgent.getAll(folderId);
+     * ```
+     */
+    getAll(folderId?: number): Promise<AgentGetResponse[]>;
+    /**
+     * Gets a specific agent by ID
+     *
+     * @param id - ID of the agent release
+     * @param folderId - ID of the folder containing the agent
+     * @returns Promise resolving to the agent
+     * {@link AgentGetByIdResponse}
+     *
+     * @example Basic usage
+     * ```typescript
+     * const agent = await conversationalAgent.getById(agentId, folderId);
+     *
+     * // Create conversation directly from agent (agentId and folderId are auto-filled)
+     * const conversation = await agent.conversations.create({ label: 'My Chat' });
+     * ```
+     */
+    getById(id: number, folderId: number): Promise<AgentGetByIdResponse>;
+    /**
+     * Registers a handler that is called whenever the WebSocket connection status changes.
+     *
+     * @param handler - Callback receiving a {@link ConnectionStatus} (`'Disconnected'` | `'Connecting'` | `'Connected'`) and an optional `Error`
+     * @returns Cleanup function to remove the handler
+     *
+     * @example
+     * ```typescript
+     * const cleanup = conversationalAgent.onConnectionStatusChanged((status, error) => {
+     *   console.log('Connection status:', status);
+     *   if (error) {
+     *     console.error('Connection error:', error.message);
+     *   }
+     * });
+     *
+     * // Later, remove the handler
+     * cleanup();
+     * ```
+     */
+    onConnectionStatusChanged(handler: (status: ConnectionStatus, error: Error | null) => void): () => void;
+    /** Service for creating and managing conversations. See {@link ConversationServiceModel}. */
+    readonly conversations: ConversationServiceModel;
+    /**
+     * Gets feature flags for the current tenant
+     *
+     * @internal
+     */
+    getFeatureFlags(): Promise<FeatureFlags>;
+}
+
+/**
+ * Options for ConversationalAgentService constructor
+ */
+interface ConversationalAgentOptions {
+    /** External User ID (optional) */
+    externalUserId?: string;
+    /** Log level for debugging */
+    logLevel?: LogLevel;
+}
+
+/**
+ * Error thrown when authorization fails (403 errors)
+ * Common scenarios:
+ * - Insufficient permissions
+ * - Access denied to resource
+ * - Invalid scope
+ */
+declare class AuthorizationError extends UiPathError {
+    constructor(params?: Partial<ErrorParams>);
+}
+
+/**
+ * Error thrown when validation fails (400 errors or client-side validation)
+ * Common scenarios:
+ * - Invalid input parameters
+ * - Missing required fields
+ * - Invalid data format
+ */
+declare class ValidationError extends UiPathError {
+    constructor(params?: Partial<ErrorParams>);
+}
+
+/**
+ * Error thrown when a resource is not found (404 errors)
+ * Common scenarios:
+ * - Resource doesn't exist
+ * - Invalid ID provided
+ * - Resource deleted
+ */
+declare class NotFoundError extends UiPathError {
+    constructor(params?: Partial<ErrorParams>);
+}
+
+/**
+ * Error thrown when rate limit is exceeded (429 errors)
+ * Common scenarios:
+ * - Too many requests in a time window
+ * - API throttling
+ */
+declare class RateLimitError extends UiPathError {
+    constructor(params?: Partial<ErrorParams>);
+}
+
+/**
+ * Error thrown when server encounters an error (5xx errors)
+ * Common scenarios:
+ * - Internal server error
+ * - Service unavailable
+ * - Gateway timeout
+ */
+declare class ServerError extends UiPathError {
+    constructor(params?: Partial<ErrorParams>);
+    /**
+     * Checks if this is a temporary error that might succeed on retry
+     */
+    get isRetryable(): boolean;
+}
+
+/**
+ * Base error creation parameters - only what's needed
+ */
+interface ErrorParams {
+    message: string;
+    statusCode?: number;
+    requestId?: string;
+}
+
+/**
+ * Base error class for all UiPath SDK errors
+ * Extends Error for standard error handling compatibility
+ */
+declare abstract class UiPathError extends Error {
+    /**
+     * Error type identifier (e.g., "AuthenticationError", "ValidationError")
+     */
+    readonly type: string;
+    /**
+     * HTTP status code (400, 401, 403, 404, 500, etc.)
+     */
+    readonly statusCode?: number;
+    /**
+     * Request ID for tracking with UiPath support
+     */
+    readonly requestId?: string;
+    /**
+     * Timestamp when the error occurred
+     */
+    readonly timestamp: Date;
     protected constructor(type: string, params: ErrorParams);
     /**
      * Returns a clean JSON representation of the error
@@ -5866,7 +10205,7 @@ declare const telemetryClient: TelemetryClient;
  * SDK Telemetry constants
  */
 declare const CONNECTION_STRING = "InstrumentationKey=a6efa11d-1feb-4508-9738-e13e12dcae5e;IngestionEndpoint=https://westeurope-5.in.applicationinsights.azure.com/;LiveEndpoint=https://westeurope.livediagnostics.monitor.azure.com/;ApplicationId=7c58eb1c-9581-4ba6-839e-11725848a037";
-declare const SDK_VERSION = "1.0.0";
+declare const SDK_VERSION = "1.1.1";
 declare const VERSION = "Version";
 declare const SERVICE = "Service";
 declare const CLOUD_ORGANIZATION_NAME = "CloudOrganizationName";
@@ -5881,5 +10220,5 @@ declare const SDK_LOGGER_NAME = "uipath-ts-sdk-telemetry";
 declare const SDK_RUN_EVENT = "Sdk.Run";
 declare const UNKNOWN = "";
 
-export { APP_NAME, AssetValueScope, AssetValueType, AuthenticationError, AuthorizationError, BucketOptions, CLOUD_CLIENT_ID, CLOUD_ORGANIZATION_NAME, CLOUD_REDIRECT_URI, CLOUD_ROLE_NAME, CLOUD_TENANT_NAME, CLOUD_URL, CONNECTION_STRING, DEFAULT_ITEMS_FIELD, DEFAULT_PAGE_SIZE, DEFAULT_TOTAL_COUNT_FIELD, DataDirectionType, DebugMode, EntityFieldDataType, EntityType, ErrorType, EscalationActionType, EscalationRecipientScope, EscalationTriggerType, FieldDisplayType, HttpStatus, JobPriority, JobState, JobType, JoinType, MAX_PAGE_SIZE, NetworkError, NotFoundError, PackageSourceType, PackageType, ProcessIncidentSeverity, ProcessIncidentStatus, ProcessIncidentType, RateLimitError, ReferenceType, RemoteControlAccess, RobotSize, SDK_LOGGER_NAME, SDK_RUN_EVENT, SDK_SERVICE_NAME, SDK_VERSION, SERVICE, SLADurationUnit, ServerError, StageTaskType, StartStrategy, StopStrategy, TargetFramework, TaskActivityType, TaskPriority, TaskSlaCriteria, TaskSlaStatus, TaskSourceName, TaskStatus, TaskType, UNKNOWN, UiPath, UiPathError, VERSION, ValidationError, createCaseInstanceWithMethods, createEntityWithMethods, createProcessInstanceWithMethods, createProcessWithMethods, createTaskWithMethods, getErrorDetails, getLimitedPageSize, isAuthenticationError, isAuthorizationError, isNetworkError, isNotFoundError, isRateLimitError, isServerError, isUiPathError, isValidationError, telemetryClient, track, trackEvent };
-export type { ArgumentMetadata, AssetGetAllOptions, AssetGetByIdOptions, AssetGetResponse, AssetServiceModel, BaseConfig, BaseOptions, BlobItem, BodyOptions, BpmnXmlString, BucketGetAllOptions, BucketGetByIdOptions, BucketGetFileMetaDataOptions, BucketGetFileMetaDataResponse, BucketGetFileMetaDataWithPaginationOptions, BucketGetReadUriOptions, BucketGetResponse, BucketGetUriOptions, BucketGetUriResponse, BucketServiceModel, BucketUploadFileOptions, BucketUploadResponse, CaseAppConfig, CaseAppOverview, CaseGetAllResponse, CaseGetStageResponse, CaseInstanceExecutionHistoryResponse, CaseInstanceGetAllOptions, CaseInstanceGetAllWithPaginationOptions, CaseInstanceGetResponse, CaseInstanceMethods, CaseInstanceOperationOptions, CaseInstanceOperationResponse, CaseInstanceReopenOptions, CaseInstanceRun, CaseInstancesServiceModel, CasesServiceModel, ChoiceSetGetAllResponse, ChoiceSetGetByIdOptions, ChoiceSetGetResponse, ChoiceSetServiceModel, CollectionResponse, CustomKeyValuePair, ElementExecutionMetadata, ElementMetaData, ElementRunMetadata, EntityBatchInsertOptions, EntityBatchInsertResponse, EntityDeleteOptions, EntityDeleteRecordsOptions, EntityDeleteResponse, EntityDownloadAttachmentOptions, EntityGetAllRecordsOptions, EntityGetRecordByIdOptions, EntityGetRecordsByIdOptions, EntityGetResponse, EntityInsertOptions, EntityInsertRecordOptions, EntityInsertRecordsOptions, EntityInsertResponse, EntityMethods, EntityOperationOptions, EntityOperationResponse, EntityRecord, EntityServiceModel, EntityUpdateOptions, EntityUpdateRecordsOptions, EntityUpdateResponse, EscalationAction, EscalationRecipient, EscalationRule, EscalationTriggerMetadata, ExternalConnection, ExternalField, ExternalFieldMapping, ExternalObject, ExternalSourceFields, FailureRecord, Field, FieldDataType, FieldMetaData, FolderProperties, GlobalVariableMetaData, HasPaginationOptions, Headers, HttpMethod, JobAttachment, JobError, Machine, MaestroProcessGetAllResponse, MaestroProcessesServiceModel, NonPaginatedResponse, OAuthFields, OperationResponse, PaginatedResponse, PaginationCursor, PaginationMetadata, PaginationMethodUnion, PaginationOptions, ProcessGetAllOptions, ProcessGetByIdOptions, ProcessGetResponse, ProcessIncidentGetAllResponse, ProcessIncidentGetResponse, ProcessIncidentsServiceModel, ProcessInstanceExecutionHistoryResponse, ProcessInstanceGetAllOptions, ProcessInstanceGetAllWithPaginationOptions, ProcessInstanceGetResponse, ProcessInstanceGetVariablesOptions, ProcessInstanceGetVariablesResponse, ProcessInstanceMethods, ProcessInstanceOperationOptions, ProcessInstanceOperationResponse, ProcessInstanceRun, ProcessInstancesServiceModel, ProcessMethods, ProcessProperties, ProcessServiceModel, ProcessStartRequest, ProcessStartResponse, QueryParams, QueueGetAllOptions, QueueGetByIdOptions, QueueGetResponse, QueueServiceModel, RawCaseInstanceGetResponse, RawEntityGetResponse, RawMaestroProcessGetAllResponse, RawProcessInstanceGetResponse, RawTaskCreateResponse, RawTaskGetResponse, RequestOptions, RequestSpec, ResponseDictionary, ResponseType, RetryOptions, RobotMetadata, SourceJoinCriteria, StageSLA, StageTask, Tag, TaskActivity, TaskAssignOptions, TaskAssignment, TaskAssignmentOptions, TaskAssignmentResponse, TaskBaseResponse, TaskCompleteOptions, TaskCompletionOptions, TaskCreateOptions, TaskCreateResponse, TaskGetAllOptions, TaskGetByIdOptions, TaskGetResponse, TaskGetUsersOptions, TaskMethods, TaskServiceModel, TaskSlaDetail, TaskSource, TasksUnassignOptions, TimeoutOptions, UiPathSDKConfig, UserLoginInfo };
+export { APP_NAME, AgentMap, AssetValueScope, AssetValueType, AuthenticationError, AuthorizationError, BucketOptions, CLOUD_CLIENT_ID, CLOUD_ORGANIZATION_NAME, CLOUD_REDIRECT_URI, CLOUD_ROLE_NAME, CLOUD_TENANT_NAME, CLOUD_URL, CONNECTION_STRING, CitationErrorType, ConversationMap, DEFAULT_ITEMS_FIELD, DEFAULT_PAGE_SIZE, DEFAULT_TOTAL_COUNT_FIELD, DataDirectionType, DebugMode, EntityFieldDataType, EntityType, ErrorType, EscalationActionType, EscalationRecipientScope, EscalationTriggerType, ExchangeMap, FeedbackRating, FieldDisplayType, HttpStatus, InputStreamSpeechSensitivity, InterruptType, JobPriority, JobState, JobType, JoinType, MAX_PAGE_SIZE, MessageMap, MessageRole, NetworkError, NotFoundError, PackageSourceType, PackageType, ProcessIncidentSeverity, ProcessIncidentStatus, ProcessIncidentType, RateLimitError, ReferenceType, RemoteControlAccess, RobotSize, SDK_LOGGER_NAME, SDK_RUN_EVENT, SDK_SERVICE_NAME, SDK_VERSION, SERVICE, SLADurationUnit, ServerError, SortOrder, StageTaskType, StartStrategy, StopStrategy, TargetFramework, TaskActivityType, TaskPriority, TaskSlaCriteria, TaskSlaStatus, TaskSourceName, TaskStatus, TaskType, UNKNOWN, UiPath, UiPathError, UserSettingsMap, VERSION, ValidationError, createAgentWithMethods, createCaseInstanceWithMethods, createConversationWithMethods, createEntityWithMethods, createProcessInstanceWithMethods, createProcessWithMethods, createTaskWithMethods, getErrorDetails, getLimitedPageSize, isAuthenticationError, isAuthorizationError, isNetworkError, isNotFoundError, isRateLimitError, isServerError, isUiPathError, isValidationError, telemetryClient, track, trackEvent };
+export type { AgentAppearance, AgentConversationServiceModel, AgentCreateConversationOptions, AgentGetByIdResponse, AgentGetResponse, AgentMethods, AgentStartingPrompt, ArgumentMetadata, AssetGetAllOptions, AssetGetByIdOptions, AssetGetResponse, AssetServiceModel, AsyncInputStream, AsyncInputStreamChunkEvent, AsyncInputStreamEndEvent, AsyncInputStreamEvent, AsyncInputStreamStartEvent, AsyncToolCallStream, BaseConfig, BaseOptions, BaseProcessStartRequest, BlobItem, BodyOptions, BpmnXmlString, BucketGetAllOptions, BucketGetByIdOptions, BucketGetFileMetaDataOptions, BucketGetFileMetaDataResponse, BucketGetFileMetaDataWithPaginationOptions, BucketGetReadUriOptions, BucketGetResponse, BucketGetUriOptions, BucketGetUriResponse, BucketServiceModel, BucketUploadFileOptions, BucketUploadResponse, CaseAppConfig, CaseAppOverview, CaseGetAllResponse, CaseGetStageResponse, CaseInstanceExecutionHistoryResponse, CaseInstanceGetAllOptions, CaseInstanceGetAllWithPaginationOptions, CaseInstanceGetResponse, CaseInstanceMethods, CaseInstanceOperationOptions, CaseInstanceOperationResponse, CaseInstanceReopenOptions, CaseInstanceRun, CaseInstancesServiceModel, CasesServiceModel, ChoiceSetGetAllResponse, ChoiceSetGetByIdOptions, ChoiceSetGetResponse, ChoiceSetServiceModel, Citation, CitationEndEvent, CitationError, CitationEvent, CitationOptions, CitationSource, CitationSourceBase, CitationSourceMedia, CitationSourceUrl, CitationStartEvent, CollectionResponse, CompletedContentPart, CompletedMessage, CompletedToolCall, ContentPart, ContentPartChunkEvent, ContentPartData, ContentPartEndEvent, ContentPartEvent, ContentPartGetResponse, ContentPartInterrupted, ContentPartStartEvent, ContentPartStartMetaData, ContentPartStream, ConversationAttachmentCreateResponse, ConversationAttachmentUploadResponse, ConversationCreateOptions, ConversationCreateResponse, ConversationDeleteResponse, ConversationEvent, ConversationExchangeServiceModel, ConversationGetAllOptions, ConversationGetResponse, ConversationJobStartOverrides, ConversationMethods, ConversationServiceModel, ConversationSessionMethods, ConversationSessionOptions, ConversationUpdateOptions, ConversationUpdateResponse, ConversationalAgentOptions, ConversationalAgentServiceModel, CreateFeedbackOptions, CustomKeyValuePair, ElementExecutionMetadata, ElementMetaData, ElementRunMetadata, EntityBatchInsertOptions, EntityBatchInsertResponse, EntityDeleteOptions, EntityDeleteRecordsOptions, EntityDeleteResponse, EntityDownloadAttachmentOptions, EntityGetAllRecordsOptions, EntityGetRecordByIdOptions, EntityGetRecordsByIdOptions, EntityGetResponse, EntityInsertOptions, EntityInsertRecordOptions, EntityInsertRecordsOptions, EntityInsertResponse, EntityMethods, EntityOperationOptions, EntityOperationResponse, EntityRecord, EntityServiceModel, EntityUpdateOptions, EntityUpdateRecordsOptions, EntityUpdateResponse, ErrorEndEvent, ErrorEvent, ErrorStartEvent, EscalationAction, EscalationRecipient, EscalationRule, EscalationTriggerMetadata, Exchange, ExchangeEndEvent, ExchangeEvent, ExchangeGetAllOptions, ExchangeGetByIdOptions, ExchangeGetResponse, ExchangeServiceModel, ExchangeStartEvent, ExchangeStream, ExternalConnection, ExternalField, ExternalFieldMapping, ExternalObject, ExternalSourceFields, ExternalValue, FailureRecord, FeatureFlags, FeedbackCreateResponse, Field, FieldDataType, FieldMetaData, FileUploadAccess, FolderProperties, GenericInterruptStartEvent, GlobalVariableMetaData, HasPaginationOptions, Headers, HttpMethod, InlineOrExternalValue, InlineValue, Interrupt, InterruptEndEvent, InterruptEvent, InterruptStartEvent, JSONArray, JSONObject, JSONPrimitive, JSONValue, JobAttachment, JobError, LabelUpdatedEvent, Machine, MaestroProcessGetAllResponse, MaestroProcessesServiceModel, MakeOptional, MakeRequired, Message, MessageEndEvent, MessageEvent, MessageGetResponse, MessageServiceModel, MessageStartEvent, MessageStream, MetaData, MetaEvent, NonPaginatedResponse, OAuthFields, OperationResponse, PaginatedResponse, PaginationCursor, PaginationMetadata, PaginationMethodUnion, PaginationOptions, ProcessGetAllOptions, ProcessGetByIdOptions, ProcessGetResponse, ProcessIncidentGetAllResponse, ProcessIncidentGetResponse, ProcessIncidentsServiceModel, ProcessInstanceExecutionHistoryResponse, ProcessInstanceGetAllOptions, ProcessInstanceGetAllWithPaginationOptions, ProcessInstanceGetResponse, ProcessInstanceGetVariablesOptions, ProcessInstanceGetVariablesResponse, ProcessInstanceMethods, ProcessInstanceOperationOptions, ProcessInstanceOperationResponse, ProcessInstanceRun, ProcessInstancesServiceModel, ProcessMethods, ProcessProperties, ProcessServiceModel, ProcessStartRequest, ProcessStartRequestWithKey, ProcessStartRequestWithName, ProcessStartResponse, QueryParams, QueueGetAllOptions, QueueGetByIdOptions, QueueGetResponse, QueueServiceModel, RawAgentGetByIdResponse, RawAgentGetResponse, RawCaseInstanceGetResponse, RawConversationGetResponse, RawEntityGetResponse, RawMaestroProcessGetAllResponse, RawProcessInstanceGetResponse, RawTaskCreateResponse, RawTaskGetResponse, RequestOptions, RequestSpec, ResponseDictionary, ResponseType, RetryOptions, RobotMetadata, SessionCapabilities, SessionEndEvent, SessionEndingEvent, SessionStartEvent, SessionStartedEvent, SessionStream, Simplify, SourceJoinCriteria, StageSLA, StageTask, Tag, TaskActivity, TaskAssignOptions, TaskAssignment, TaskAssignmentOptions, TaskAssignmentResponse, TaskBaseResponse, TaskCompleteOptions, TaskCompletionOptions, TaskCreateOptions, TaskCreateResponse, TaskGetAllOptions, TaskGetByIdOptions, TaskGetResponse, TaskGetUsersOptions, TaskMethods, TaskServiceModel, TaskSlaDetail, TaskSource, TasksUnassignOptions, TimeoutOptions, ToolCall, ToolCallConfirmationEndValue, ToolCallConfirmationInterruptStartEvent, ToolCallConfirmationValue, ToolCallEndEvent, ToolCallEvent, ToolCallInputValue, ToolCallOutputValue, ToolCallResult, ToolCallStartEvent, ToolCallStream, UiPathSDKConfig, UserLoginInfo, UserServiceModel, UserSettingsGetResponse, UserSettingsUpdateOptions, UserSettingsUpdateResponse };