@aintela/chat 0.2.15

package/dist/src/models/subAgentModel.d.ts

@@ -0,0 +1,48 @@
+import { TodoList } from './todoListModel';
+/**
+ * Mirrors `Envision.SemanticKernel.Core.SubAgent.SubAgentStatus` enum on the
+ * server. Values come back as plain strings (the controller uses `Status.ToString()`).
+ */
+export type SubAgentStatus = 'Pending' | 'Running' | 'Completed' | 'Failed' | 'Cancelled' | 'Unknown';
+/**
+ * Lightweight representation of a chat message embedded in the SubAgentDto.
+ * The server-side `Message` type carries more fields, but only the basics are
+ * needed for status polling on the client.
+ */
+export interface SubAgentMessage {
+    id?: string;
+    role?: string;
+    content?: string;
+    [key: string]: unknown;
+}
+/**
+ * TypeScript counterpart of `Envision.SemanticKernel.Core.SubAgent.SubAgentDto`.
+ *
+ * This is the payload returned by `GET /SubAgent/{sessionId}/{id}`.
+ *
+ * `TodoList.percentComplete` is serialized by the server as a fraction in the
+ * range `[0, 1]` (i.e. `completedItems / totalItems`). It can be `NaN` when the
+ * todo list is empty, so consumers should guard against non-finite values.
+ */
+export interface SubAgentDto {
+    id?: string;
+    subAgentId: string;
+    name: string;
+    sessionId?: string;
+    dashboardId?: string | null;
+    todoList?: TodoList | null;
+    generalInstructions?: string | null;
+    dashboardInstructions?: string | null;
+    detailedStatus?: string | null;
+    status: SubAgentStatus | string;
+    error?: string | null;
+    hasResult?: boolean | null;
+    finalSummary?: string | null;
+    parameters?: Record<string, string> | null;
+    updatedAt?: string | Date | null;
+    created?: string | Date | null;
+    message?: SubAgentMessage | null;
+}
+/** Status values that indicate the sub-agent is no longer making progress. */
+export declare const SUB_AGENT_TERMINAL_STATUSES: ReadonlyArray<SubAgentStatus>;
+export declare function isSubAgentTerminalStatus(status: string | undefined | null): boolean;

package/dist/src/models/todoListModel.d.ts

@@ -0,0 +1,18 @@
+export type TodoItemStatus = 'Pending' | 'pending' | 'in_progress' | 'InProgress' | 'Completed' | 'completed' | 'Failed' | 'failed';
+export interface TodoList {
+    id?: string;
+    title?: string;
+    items: TodoItem[];
+    currentWorkingItemKey?: string;
+    /**
+     * Fraction of completed items in the range `[0, 1]` (e.g. `0.4` means 40%).
+     * Computed and serialized by the server. Can be `NaN` when `items` is empty.
+     */
+    percentComplete?: number;
+}
+export interface TodoItem {
+    key: string;
+    label: string;
+    status: TodoItemStatus;
+    detail?: string;
+}

package/dist/src/services/WebSocketConnection/WebSocketConnectionV2.d.ts

@@ -0,0 +1,163 @@
+import { ServerEvent } from '../../models/ServerEvent';
+import { TypedJSON } from 'typedjson';
+import { InteractionStatistics, LlmEvent, StreamingResponse } from '../../models/semanticKernelModel/models';
+import { IWebSocketConnection, IMessage, IMessageBase } from './webSocketConnection';
+export declare const APPLICATION_CLOSED_CODE = 4001;
+/**
+ * The server uses this WS close code when rejecting a duplicate attachment for the
+ * same sessionId (single-attach policy in InteractionRunRegistry). The user already
+ * has another WS connected for this session — usually another browser tab — so
+ * silently auto-reconnecting would just bounce the rejection forever. Surface the
+ * close to the consumer instead.
+ */
+export declare const SESSION_ALREADY_ATTACHED_CODE = 4002;
+export declare class WebSocketConnecionV2 implements IWebSocketConnection {
+    ws: WebSocket | null;
+    stats: InteractionStatistics;
+    baseUrl: string;
+    /**
+     * Optional callback that returns the current JWT. We re-evaluate it on every connect/reconnect
+     * so that a refreshed token is picked up automatically. Browsers can't set the Authorization
+     * header on the WebSocket handshake, so we pass the JWT via the ?access_token= query string,
+     * which the .NET JwtBearer events handler reads in Program.cs.
+     */
+    getToken?: () => string | undefined;
+    onEvent?: (event: MessageEvent | ServerEvent) => Promise<void>;
+    onError?: (error: string) => void;
+    onOpen?: () => void;
+    onFirstToken?: (interactionId: string) => void;
+    onSuspended?: () => void;
+    onPong?: (sessionId: string) => void;
+    onClose?: (code: number, reason: string) => void;
+    /** Fired when an unexpected close triggers a reconnect attempt. */
+    onReconnecting?: (attempt: number, delayMs: number) => void;
+    /** Fired the first time the socket reopens after an unexpected close. */
+    onReconnected?: (sessionId: string) => void;
+    /**
+     * Fired when the server signals that we lost streaming events on resume — our
+     * `lastSeq` fell off the end of the in-memory replay buffer. Consumers should
+     * reset partial-streaming UI for this session and rely on persisted history.
+     */
+    onRewindLost?: (sessionId: string, resumingFromSeq: number) => void;
+    sessionId?: string;
+    onNewPacket?: (stats: InteractionStatistics) => void;
+    /**
+     * Stats can fire dozens of times per second during streaming. We
+     * coalesce to a fixed cadence so subscribers see steady,
+     * digestible updates instead of a per-packet firehose — the
+     * latter caused a "Maximum update depth exceeded" cascade in
+     * heavy v2 surfaces (RunProgressPanelV2 + StreamStatistics +
+     * ChatTranscript all subscribed to `statistics` and re-rendered
+     * on every packet, with their useEffect-driven setStates pushing
+     * React's nested-update counter past its threshold).
+     */
+    private statsFlushTimer;
+    private statsLastFlushed;
+    private readonly STATS_FLUSH_MS;
+    monitorInterval: NodeJS.Timeout | null;
+    streamingResponseSerializer: TypedJSON<StreamingResponse>;
+    events: [number, number][];
+    lastActivity: number;
+    pingPongStack: number[];
+    firstTokenInteractions: Set<string>;
+    /** Last sessionId we successfully had — used to resume on reconnect. */
+    private lastKnownSessionId?;
+    /** True when the consumer called `disconnect()` — suppresses auto-reconnect. */
+    private intentionalDisconnect;
+    /** Number of reconnect attempts since the last clean open. */
+    private reconnectAttempts;
+    private reconnectTimer;
+    /** True while we are in the middle of an unexpected-close → reconnect cycle. */
+    private isReconnecting;
+    /** Internal flag set by `scheduleReconnect` so `connect()` does not reset the backoff state. */
+    private _internalReconnect;
+    /**
+     * Highest server-assigned `seq` we have observed and processed. The next
+     * reconnect appends `?lastSeq={lastSeq}` so the server can replay anything
+     * we missed from the InteractionRun's in-memory buffer. -1 means "haven't
+     * seen any sequenced events yet" (fresh connection).
+     */
+    private lastSeq;
+    /**
+     * True once *any* socket on this instance has received at least one packet.
+     * Used by `onclose` to distinguish a real mid-stream drop (we had a working
+     * channel) from a connect attempt that never produced traffic (server down,
+     * unreachable, etc.). The inner reconnect loop is only meant for the former
+     * — fresh-connect failures should be handed straight to the outer
+     * SessionStateManagerService.processRetryLoop instead of being retried
+     * twice in here. Sticky for the lifetime of this connection instance so
+     * that internal resume attempts keep their full inner-loop budget even
+     * when a replacement socket fails before delivering its first message.
+     * Cleared by `disconnect()`.
+     */
+    private hasEverReceivedPacket;
+    constructor(baseUrl?: string, getToken?: () => string | undefined);
+    /**
+     * Connect to the WebSocket endpoint
+     */
+    connect(sessionId?: string): Promise<string>;
+    /**
+     * Returns true when the close code is something we believe a fresh connect
+     * (with the same sessionId) can recover from. We deliberately do NOT retry
+     * on:
+     *   - 1000 normal closure
+     *   - 1008 policy violation (auth rejected)
+     *   - 4001 our own intentional disconnect
+     *   - 4000-4099 reserved for app-level fatal codes from the server
+     */
+    private shouldAttemptReconnect;
+    private cancelPendingReconnect;
+    private computeBackoffDelay;
+    private scheduleReconnect;
+    sleep(ms: number): Promise<unknown>;
+    /**
+     * Handle incoming messages from server
+     */
+    handleMessage(streamingResponse: StreamingResponse, rawData: string): LlmEvent | null | undefined;
+    protected emitFirstToken(interactionId?: string): void;
+    /**
+     * Mirror a server-side-refreshed JWT into the stored user record so the global
+     * fetch interceptor (packages/dashboard-app/.../EnvisionAuthProvider.tsx) picks
+     * it up on the next HTTP call. Idempotent — the same token is delivered on
+     * multiple consecutive Pong frames for listener-readiness, and we only write
+     * when it actually changed.
+     *
+     * Uses the same localStorage key the auth provider reads (`envision_user`).
+     * Done here in the WS layer rather than via a callback so consumers don't need
+     * to wire up token-handling boilerplate; React contexts that hold the user in
+     * memory will pick up the new token on the next refresh/render or via their
+     * own storage listeners.
+     */
+    private persistRefreshedAccessToken;
+    closeStream(): void;
+    suspendStream(): void;
+    /** Send the user's answer to a parked ask_user tool call (ChatAction.AnswerHumanTool). */
+    answerHumanTool(toolCallId: string, answer: string): void;
+    /**
+     * Send a message to the agent
+     */
+    sendMessage(message: IMessage): void;
+    sendBaseMessage(message: IMessageBase): void;
+    sendSuspendMessage(message: IMessage): void;
+    monitor(): void;
+    /**
+     * Send a heartbeat ping
+     */
+    ping(): void;
+    /**
+     * Disconnect the WebSocket
+     */
+    disconnect(): void;
+    /**
+     * Check if connected
+     */
+    isConnected(): boolean;
+    /**
+     * Push the latest stats out to `onNewPacket`, but at most every
+     * `STATS_FLUSH_MS` ms. Subsequent packets within the window
+     * schedule a trailing flush so the UI eventually sees the final
+     * value without each individual packet causing a re-render.
+     */
+    private flushStatsCoalesced;
+    handleEvent(llmEvent: LlmEvent, rawData: string): Promise<void>;
+}

package/dist/src/services/WebSocketConnection/webSocketConnection.d.ts

@@ -0,0 +1,75 @@
+import { ServerEvent } from '../../models/ServerEvent';
+import { ChatAction } from '../../models/enums';
+import { InteractionStatistics } from '../../models/semanticKernelModel/models';
+export interface IMessageBase {
+    Action: ChatAction;
+    ModelId?: string;
+    AgentId: string;
+    InteractionId: string;
+    /** ask_user answer routing (Action === 'AnswerHumanTool'): the parked tool-call id and the user's answer. */
+    ToolCallId?: string;
+    Answer?: string;
+}
+export interface IMessageImage {
+    MimeType: string;
+    /** Base64-encoded payload (no data-URL prefix). */
+    Data: string;
+}
+export interface IMessage extends IMessageBase {
+    Content: string;
+    SessionId?: string;
+    Parameters?: {
+        [key: string]: string;
+    };
+    CustumerId?: string;
+    /**
+     * Optional explicit C# class name to dispatch the turn to (e.g.
+     * `"LlmAgentSessionReplay"`). When set, `AgentBootStrapService.GetAgent`
+     * resolves the LlmAgent directly by type name and skips the Mongo
+     * Agents-collection lookup. Used by the replay demo so a host can target
+     * any registered LlmAgent variant without seeding a metadata row.
+     */
+    AgentImplementation?: string;
+    /**
+     * Optional image attachments. Server-side `Message.Images` mirrors this
+     * shape; PascalCase here is intentional so System.Text.Json deserialises
+     * straight onto the C# model.
+     */
+    Images?: IMessageImage[];
+    /**
+     * Optional client-only UI representation for this user turn. Server-side
+     * `Message.UserUi` mirrors this shape (PascalCase for System.Text.Json). The server
+     * persists it as a `UserUiContent` sibling and strips it from the model request, so
+     * `Content` stays the only model-facing text. `Args` is a serialized JSON string.
+     */
+    UserUi?: {
+        Name: string;
+        Args?: string;
+    };
+}
+export interface IWebSocketConnection {
+    onEvent?: (event: MessageEvent | ServerEvent) => Promise<void>;
+    onError?: (error: string) => void;
+    onOpen?: () => void;
+    onFirstToken?: (interactionId: string) => void;
+    onSuspended?: () => void;
+    onClose?: (code: number, reason: string) => void;
+    onNewPacket?: (stats: InteractionStatistics) => void;
+    onPong?: (sessionId: string) => void;
+    /** Emitted when an unexpected close kicks off the auto-reconnect loop. */
+    onReconnecting?: (attempt: number, delayMs: number) => void;
+    /** Emitted on the first successful re-open after one or more reconnect attempts. */
+    onReconnected?: (sessionId: string) => void;
+    /**
+     * Emitted when the server signals that some events were lost on resume —
+     * our `lastSeq` was older than its in-memory replay buffer. UI should
+     * reset partial-streaming state for the affected session.
+     */
+    onRewindLost?: (sessionId: string, resumingFromSeq: number) => void;
+    connect: (sessionId?: string) => Promise<string>;
+    sendMessage: (message: IMessage) => void;
+    suspendStream: () => void;
+    disconnect: () => void;
+    closeStream: () => void;
+    isConnected: () => boolean;
+}

package/dist/src/services/artifactHtmlHandler.d.ts

@@ -0,0 +1,6 @@
+import { Theme } from '@mui/material/styles';
+export declare class ArtifactHtmlHandler {
+    static defaultIframeScript: string;
+    static replaceVarText: (artifactHtml: string, _theme: Theme) => string;
+    static handleArtifactHtml(artifactHtml: string, _mode: 'full' | 'compact', _isMobile: boolean, theme: Theme): string;
+}

package/dist/src/services/eventBusService.d.ts

@@ -0,0 +1,119 @@
+import { EndMessageData } from '../models/EndMessageData';
+import { ArtifactData } from '../models/ArtifactData';
+import { ChatSession } from '../models/ChatSession';
+import { Interaction, MergeResult } from '../models/Interaction';
+import { FunctionDetails } from '../models/ServerEvent';
+import { Artifact } from '../models/Artifact';
+import { ConnectionState } from '../models/connectionState';
+import { InteractionStatistics } from '../models/semanticKernelModel/models';
+export interface FirstTokenEventDetails {
+    interactionId: string;
+    callId?: string;
+}
+export declare class EventTypes {
+    activityLost: string;
+    artifactGenerated: string;
+    artifactSelected: string;
+    artifactDeleted: string;
+    gatewayMessage: string;
+    gatewayTurnComplete: string;
+    gatewayStreamError: string;
+    gatewayTurnOpen: string;
+    sessionCreated: string;
+    sessionUpdated: string;
+    gatewayFunctionResponse: string;
+    uiUnsavedPopoverToggle: string;
+    artifactsStorageUpdated: string;
+    gatewayStreamEnded: string;
+    streamNewChunk: string;
+    gatewayEndMessageData: string;
+    connectionStateChange: string;
+    onMessageSent: string;
+    onMessageError: string;
+    onToolEvent: string;
+    gatewayFirstToken: string;
+}
+export declare const allEventTypes: EventTypes;
+export declare class EventBusService {
+    protected listeners: {
+        [methodName: string]: ((...args: any) => Promise<void>)[];
+    };
+    protected listenersCount: {
+        [methodName: string]: number;
+    };
+    protected callListeners(eventName: string, ...args: any[]): void;
+    protected addListener(eventName: string, listener: (...args: any) => Promise<void>): void;
+    getEventState(eventName: string): number;
+    activityOnLost(listener: (...args: any) => Promise<void>): void;
+    activityEmitLost(): void;
+    artifactOnGenerated(listener: (artifact: Artifact) => Promise<void>): void;
+    artifactEmitGenerated(artifact: Artifact): void;
+    artifactOffGenerated(listener: (artifact: Artifact) => Promise<void>): void;
+    artifactOnSelected(listener: (artifact: Artifact | string) => Promise<void>): void;
+    artifactEmitSelected(artifact: Artifact | string): void;
+    artifactOffSelected(listener: (artifact: Artifact | string) => Promise<void>): void;
+    artifactOnDeleted(listener: (artifact: Artifact) => Promise<void>): void;
+    artifactEmitDeleted(artifact: ArtifactData): void;
+    artifactOffDeleted(listener: (artifact: ArtifactData) => Promise<void>): void;
+    gatewayOnMessage(listener: (interaction: Interaction, messageDetails: MergeResult | null) => Promise<void>): void;
+    gatewayOnTurnComplete(listener: (interactionId: string, interaction: Interaction) => Promise<void>): void;
+    gatewayOnTurnOpen(listener: (interactionId: string) => Promise<void>): void;
+    gatewayOnStreamError(listener: (...args: any[]) => Promise<void>): void;
+    gatewayOnStreamEnded(listener: (...args: any[]) => Promise<void>): void;
+    gatewayOffStreamEnded(listener: (...args: any[]) => Promise<void>): void;
+    gatewayEmitStreamEnded(interactionId: string, interaction: Interaction): void;
+    gatewayEmitMessage(agentInteraction: Interaction, messageDetails?: MergeResult | null): void;
+    gatewayEmitTurnComplete(interactionId: string, agentInteraction: Interaction): void;
+    gatewayEmitStreamError(errorMessage: string): void;
+    gatewayEmitTurnOpen(interactionId: string): void;
+    gatewayOffMessage(listener: (interaction: Interaction, messageDetails: MergeResult | null) => Promise<void>): void;
+    gatewayOffTurnComplete(listener: (interactionId: string, interaction: Interaction) => Promise<void>): void;
+    gatewayOffTurnOpen(listener: (interactionId: string) => Promise<void>): void;
+    gatewayOffStreamError(listener: (...args: any[]) => Promise<void>): void;
+    sessionOnCreated(listener: (...args: any[]) => Promise<void>): void;
+    chatOnMessageSent(listener: (messate: string, interaction: Interaction) => Promise<void>): void;
+    chatOffMessageSent(listener: (...args: any[]) => Promise<void>): void;
+    ChatEmitMessageSent(message: string, interaction: Interaction): void;
+    chatOnMessageError(listener: (error: string) => Promise<void>): void;
+    chatOffMessageError(listener: (...args: any[]) => Promise<void>): void;
+    ChatEmitMessageError(error: string): void;
+    sessionOnUpdated(listener: (...args: any[]) => Promise<void>): void;
+    sessionEmitCreated(session: ChatSession): void;
+    sessionEmitUpdated(session: ChatSession): void;
+    sessionOffCreated(listener: (...args: any[]) => Promise<void>): void;
+    sessionOffUpdated(listener: (...args: any[]) => Promise<void>): void;
+    gatewayEmitFunctionResponse(functionDetails: FunctionDetails): void;
+    gatewayOffFunctionResponse(listener: (...args: any[]) => Promise<void>): void;
+    gatewayOnFunctionResponse(listener: (...args: any[]) => Promise<void>): void;
+    uiOnUnsavedPopoverToggle(listener: (anchorEl: HTMLElement | null) => Promise<void>): void;
+    uiEmitUnsavedPopoverToggle(anchorEl: HTMLElement | null): void;
+    uiOffUnsavedPopoverToggle(listener: (anchorEl: HTMLElement | null) => Promise<void>): void;
+    artifactsOnStorageUpdated(listener: () => Promise<void>): void;
+    artifactsEmitStorageUpdated(): void;
+    artifactsOffStorageUpdated(listener: () => Promise<void>): void;
+    streamOnNewChunk(listener: (stats: InteractionStatistics) => Promise<void>): void;
+    streamEmitNewChunk(stats: InteractionStatistics): void;
+    streamOffNewChunk(listener: (stats: InteractionStatistics) => Promise<void>): void;
+    gatewayOnEndMessageData(listener: (data: EndMessageData) => Promise<void>): void;
+    gatewayEmitEndMessageData(data: EndMessageData): void;
+    gatewayOffEndMessageData(listener: (data: EndMessageData) => Promise<void>): void;
+    gatewayOnConnectionStateChange(listener: (state: ConnectionState) => Promise<void>): void;
+    gatewayEmitConnectionStateChange(state: ConnectionState): void;
+    gatewayOffConnectionStateChange(listener: (state: ConnectionState) => Promise<void>): void;
+    gatewayOnToolEvent(listener: (eventName: string, eventData: string, sessionId?: string) => Promise<void>): void;
+    gatewayEmitToolEvent(eventName: string, eventData: string, sessionId?: string): void;
+    gatewayOffToolEvent(listener: (eventName: string, eventData: string, sessionId?: string) => Promise<void>): void;
+    gatewayOnFirstToken(listener: (details: FirstTokenEventDetails) => Promise<void>): void;
+    gatewayEmitFirstToken(details: FirstTokenEventDetails): void;
+    gatewayOffFirstToken(listener: (details: FirstTokenEventDetails) => Promise<void>): void;
+}
+export declare class MockEventBusService extends EventBusService {
+    constructor();
+    gatewayEmitConnectionStateChange(_state: ConnectionState): void;
+    gatewayEmitMessage(agentInteraction: Interaction, _messageDetails?: MergeResult): void;
+    gatewayEmitTurnComplete(_interactionId: string, _agentInteraction: Interaction): void;
+    gatewayEmitTurnOpen(_interactionId: string): void;
+    gatewayEmitFunctionResponse(_functionDetails: FunctionDetails): void;
+    gatewayOnFunctionResponse(listener: (...args: any[]) => Promise<void>): void;
+    gatewayOffFunctionResponse(listener: (...args: any[]) => Promise<void>): void;
+}

package/dist/src/services/httpArtifactService.d.ts

@@ -0,0 +1,25 @@
+import { Artifact } from '../models/Artifact';
+import { IArtifactService } from './interfaces/artifactService';
+/**
+ * Minimal IArtifactService for the replay demo. The replay path doesn't
+ * generate artifacts — every persisted FunctionResultContent carries its
+ * own payload — so most operations are in-memory pass-throughs. Hosts
+ * that need full artifact handling supply their own implementation.
+ */
+export declare class HttpArtifactService implements IArtifactService {
+    private cache;
+    private serverBaseUrl;
+    private accessToken;
+    constructor(serverBaseUrl: string, accessToken: string);
+    private get headers();
+    init(): Promise<void>;
+    getArtifacts(): Artifact[];
+    saveArtifact(artifact: Artifact): Promise<void>;
+    saveArtifactToCache(artifact: Artifact): void;
+    deleteArtifact(artifactId: string): Promise<void>;
+    addToCache(artifact: Artifact): void;
+    getArtifactWithCache(artifactId: string): Artifact | null;
+    getArtifact(artifactId: string, _useCache?: boolean): Promise<Artifact | null>;
+    clearAllArtifacts(): Promise<void>;
+    getFileContent(url: string): Promise<string | null>;
+}

package/dist/src/services/httpSessionService.d.ts

@@ -0,0 +1,31 @@
+import { ChatSession, Customer, ISessionService } from '..';
+/**
+ * Minimal ISessionService over the WSServer's REST `/sessions` endpoints.
+ *
+ * Reads from the unified `Sessions` collection. The list endpoint returns
+ * header projections; the detail endpoint returns header + the raw
+ * `LlmEvent[]` log which we replay through `decodeSessionEvents` to rebuild
+ * the chat UI's `Interaction[]`. Mutation methods are no-ops — write paths
+ * are exercised by the live agent turn loop and the WS connection, not by
+ * REST calls from the picker.
+ */
+export declare class HttpSessionService implements ISessionService {
+    private serverBaseUrl;
+    private accessToken;
+    constructor(serverBaseUrl: string, accessToken: string);
+    private get headers();
+    getAllSessions(): Promise<ChatSession[]>;
+    retrieveSession(sessionId: string): Promise<ChatSession | null>;
+    getLastUsedSession(): Promise<ChatSession | null>;
+    removeSession(sessionId: string): Promise<void>;
+    createSession(_sessionId: string, _agentName: string, _customer?: Customer): Promise<ChatSession | null>;
+    createAgentSession(): Promise<any>;
+    closeSession(_sessionId: string): Promise<void>;
+    generateOverviewForCurrentSession(_sys: string, _model: string): Promise<string | null>;
+    storeSession(session: ChatSession): Promise<any>;
+    patchSession(sessionId: string, partial: Partial<ChatSession>): Promise<void>;
+    delayedPatchActiveSession(_partial: Partial<ChatSession>): void;
+    patchActiveSession(_partial: Partial<ChatSession>): Promise<ChatSession | null>;
+    getLlmSessionInformation(): Promise<any>;
+    transformIntoInstances(session: ChatSession): ChatSession;
+}

package/dist/src/services/index.d.ts

@@ -0,0 +1,16 @@
+export type { ISessionService } from './servers/sessionService/ISessionService';
+export type { IArtifactService } from './interfaces/artifactService';
+export type { IStorageService } from './storageService';
+export { LocalStorageService } from './storageService';
+export { EventBusService } from './eventBusService';
+export type { FirstTokenEventDetails } from './eventBusService';
+export { AgentGatewayService } from './servers/AgentGatewayService';
+export type { GatewaySendMessageOptions } from './servers/AgentGatewayService';
+export { AgentGatewayWSAsync } from './servers/AgentGatewayWSAsync';
+export { WebSocketConnecionV2 } from './WebSocketConnection/WebSocketConnectionV2';
+export type { IWebSocketConnection, IMessage } from './WebSocketConnection/webSocketConnection';
+export { ArtifactHtmlHandler } from './artifactHtmlHandler';
+export { InteractionService } from './interactionService';
+export { decodeSessionEvents } from './sessionEventDecoder';
+export { HttpSessionService } from './httpSessionService';
+export { HttpArtifactService } from './httpArtifactService';

package/dist/src/services/interactionService.d.ts

@@ -0,0 +1,28 @@
+import { MergeResult, Interaction } from '../models/Interaction';
+import { InteractionPart } from '../models/InteractionPart';
+import { ServerEvent } from '../models/ServerEvent';
+import { EventType } from '../models/enums';
+import { EventBusService } from './eventBusService';
+export type InteractionPartGroupType = 'inline' | 'block';
+export declare const InteractionPartGroupType: {
+    readonly inline: "inline";
+    readonly block: "block";
+};
+export declare class InteractionPartGroup {
+    parts: InteractionPart[];
+    isLastGroup: boolean;
+    hasThoughts: boolean;
+    lastWithThoughts: boolean;
+    type: InteractionPartGroupType;
+}
+export declare class InteractionService {
+    interaction: Interaction;
+    eventBusService: EventBusService;
+    constructor(interaction: Interaction, eventBusService: EventBusService);
+    expandSubParts(text: string, parentPartId: string): InteractionPart[];
+    groupPartsByDisplayType(parts: InteractionPart[], partial?: boolean, showToolCalls?: boolean): InteractionPartGroup[];
+    isFunctionCall(eventType: EventType): boolean;
+    isFunctionResponse(eventType: EventType): boolean;
+    private parseTextIntoParts;
+    merge(serverEvent: ServerEvent): MergeResult;
+}

package/dist/src/services/interactionService.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/services/interfaces/artifactService.d.ts

@@ -0,0 +1,13 @@
+import { Artifact } from '../../models/Artifact';
+export interface IArtifactService {
+    getArtifacts(): Artifact[] | Promise<Artifact[]>;
+    saveArtifact(artifact: Artifact): void | Promise<void>;
+    saveArtifactToCache(artifact: Artifact): void;
+    deleteArtifact(artifactId: string): void | Promise<void>;
+    addToCache(artifact: Artifact): void;
+    getArtifactWithCache(artifactId: string): Artifact | null;
+    getArtifact(artifactId: string, useCache?: boolean): Promise<Artifact | null>;
+    clearAllArtifacts(): void | Promise<void>;
+    getFileContent(url: string): Promise<string | null>;
+    init(): Promise<void>;
+}