@aintela/chat 0.2.15

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

@@ -0,0 +1,57 @@
+import { Interaction } from './Interaction';
+import { AgentType, RunMode, SkillLevel } from './enums';
+import { Customer } from './Customer';
+import { User } from '../models/contexts';
+import { IDBStorable } from './IDBStorable';
+export interface SharedUser {
+    email: string;
+    permission: 'view' | 'interact';
+}
+export interface ChatSession extends IDBStorable {
+    toolSessionId?: string;
+    fullyLoaded: boolean;
+    loadError?: string;
+    artifacts: string[];
+    browserScopeId: string;
+    interactions: Interaction[];
+    userDescription?: string;
+    overview: string;
+    lastQuestion?: string | null;
+    agentType: AgentType;
+    customer?: Customer | null;
+    activityCount: number;
+    interactionsCount?: number;
+    allPartsCount?: number;
+    user: User;
+    lastGeneratedOverview?: Date | null;
+    skillLevel?: SkillLevel;
+    sessionRunMode: RunMode;
+}
+export declare class ChatSessionUtils {
+    static truncateText(text: string, maxLength: number): string;
+    static truncateSessionForStorage(chatSession: ChatSession): {
+        toolSessionId?: string;
+        fullyLoaded: boolean;
+        loadError?: string;
+        artifacts: string[];
+        browserScopeId: string;
+        interactions: Interaction[];
+        userDescription?: string;
+        overview: string;
+        lastQuestion?: string | null;
+        agentType: AgentType;
+        customer?: Customer | null;
+        activityCount: number;
+        interactionsCount?: number;
+        allPartsCount?: number;
+        user: User;
+        lastGeneratedOverview?: Date | null;
+        skillLevel?: SkillLevel;
+        sessionRunMode: RunMode;
+        id?: string;
+        created: Date;
+        updatedAt?: Date;
+        collectionName?: string;
+    };
+    static truncateInteractionsForStorage(originalInteractions: Interaction[]): Interaction[];
+}

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

@@ -0,0 +1,38 @@
+/**
+ * A single image attachment carried alongside a ClientMessage. `data`
+ * is the raw base64 payload (no `data:<mime>;base64,` prefix) so the
+ * server can `Convert.FromBase64String` directly into bytes.
+ */
+export interface ClientMessageImage {
+    mimeType: string;
+    data: string;
+}
+export declare class ClientMessage {
+    mimeType: string;
+    data: string;
+    friendlyMessage?: string;
+    fake?: boolean;
+    /**
+     * Optional image attachments that travel as a structured payload
+     * on the WS frame (see `IMessage.Images`). Kept separate from
+     * `data` so we don't have to encode them into the text body — the
+     * server adds them as `ImageContent` entries on the user turn.
+     */
+    images?: ClientMessageImage[];
+    /**
+     * Optional client-only UI representation for this user turn. Carried to the
+     * server as a `UserUiContent` sibling (persisted + replayed) but stripped from
+     * every model request — `data` stays the only model-facing text. `args` is a
+     * serialized JSON string. The gateway also injects a matching `UserAnswer` part
+     * on the live interaction so the component renders immediately.
+     */
+    userUi?: {
+        name: string;
+        args?: string;
+    };
+    toPythonJson(): {
+        mime_type: string;
+        data: string;
+    };
+    constructor(data: string, mimeType: string, fake?: boolean, friendlyMessage?: string, images?: ClientMessageImage[]);
+}

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

@@ -0,0 +1,7 @@
+export interface Customer {
+    dataSetId: string;
+    name: string;
+}
+export interface CustomerApiResponse {
+    customers: Customer[];
+}

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

@@ -0,0 +1,6 @@
+import { SkillLevel } from './enums';
+export interface EndMessageData {
+    category?: string;
+    summary?: string;
+    transferTo?: SkillLevel;
+}

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

@@ -0,0 +1,8 @@
+import { ChatSession } from './ChatSession';
+import { User, AgentContext } from './contexts';
+export interface IEbiContextData {
+    user?: User;
+    context: AgentContext | null;
+    session: ChatSession | null;
+    sessionId: string | null;
+}

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

@@ -0,0 +1,14 @@
+/**
+ * Base interface for all database-storable entities
+ * Provides common properties and collection name management
+ */
+export interface IDBStorable {
+    /** Unique identifier for the document */
+    id?: string;
+    /** When the document was created */
+    created: Date;
+    /** When the document was last updated */
+    updatedAt?: Date;
+    /** The Firestore collection name for this entity type */
+    readonly collectionName?: string;
+}

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

@@ -0,0 +1,36 @@
+import { TodoList } from './todoListModel';
+import { Artifact } from './Artifact';
+import { InteractionPart } from './InteractionPart';
+export interface MergeResult {
+    updatedInteraction: Interaction;
+    updatedParts: InteractionPart[];
+    newArtifacts: Partial<Artifact>[] | null;
+    mainBranch: Interaction | null;
+    analyticsBranch: Interaction | null;
+    mainBranchPartsChanged: InteractionPart[] | null;
+    analyticsBranchPartsChanged: InteractionPart[] | null;
+}
+export interface TurnOpenCloseDetails {
+    stack: string[];
+    turnClosed: boolean;
+}
+export interface Interaction {
+    isSuspended?: boolean;
+    created: Date;
+    interactionId: string;
+    sessionId?: string;
+    artifactData: Artifact[];
+    partial: boolean;
+    todoList?: TodoList;
+    turn_complete?: boolean;
+    isFinalResponse?: boolean;
+    interactionQuestion?: string;
+    asyncFinalResponse?: boolean;
+    version: number;
+    parts: InteractionPart[];
+    turnOpenCloseStack?: TurnOpenCloseDetails;
+    agentServerBaseUrl?: string | null;
+    functionMap?: Map<string, InteractionPart>;
+    contextStatus?: any;
+    taskLists?: Map<string, string>;
+}

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

@@ -0,0 +1,69 @@
+import { FunctionDetails, CodeExecutionResultDetails, ExecutableCodeDetails, ThoughtDetails, ErrorDetails, TextDetails, ToolEventDetails } from './ServerEvent';
+import { EventType } from './enums';
+export interface InteractionPart {
+    id: string;
+    eventType: EventType;
+    author: string;
+    functionDetails?: FunctionDetails;
+    codeExecutionResultDetails?: CodeExecutionResultDetails;
+    executableCodeDetails?: ExecutableCodeDetails;
+    thoughtDetails?: ThoughtDetails;
+    toolDetails?: ToolEventDetails;
+    textDetails?: TextDetails;
+    errorDetails?: ErrorDetails;
+    visible?: boolean;
+    created: Date;
+    ended?: Date;
+    text?: string;
+    hasTask?: boolean;
+    rawDetails?: any;
+    textLastChunk?: string;
+    thoughtLastChunk?: string;
+    partial: boolean;
+    isStillWriting: boolean;
+    mustPush: boolean;
+    textAppendable: boolean;
+    waitingDetails?: {
+        stopPoint?: Date;
+        addTimer: boolean;
+        isTimerRunning: boolean;
+        status: string;
+        startingPoint: Date;
+        loadDots?: boolean;
+    };
+}
+export declare class InteractionPartUtils {
+    static replaceFirstTwoTabsPerLine(value?: any): string;
+    static jsonToString(json: any): string;
+    static functionDetailsToString(obj: any | undefined): string;
+    /**
+     * Reads the server-generated SlotId from a UI render tool's result. The
+     * result reaches the client as a plain object on the live path, but as a
+     * JSON string — sometimes double-encoded (a JSON string of a JSON string) —
+     * on the persisted / session-replay path. Unwrap up to two string layers
+     * before reading the field. Returns undefined when absent or unparseable.
+     */
+    static uiSlotId(part?: InteractionPart): string | undefined;
+    static fromError(errorMsg: string): InteractionPart;
+    static fromText(text: string, author?: string, id?: string): InteractionPart;
+    /**
+     * Builds the user-authored UI part for a `sendMessage(text, { ui })` turn. Mirrors the
+     * shape `ServerEvent` produces from a persisted `UserUiContent` on reload, so the live
+     * and replayed parts are identical: an `EventType.UserAnswer` carrying functionDetails
+     * {name, args, isUi, status:'Done'} that routes through the uiTool dispatcher/registry.
+     */
+    static fromUserUi(name: string, args?: string, id?: string): InteractionPart;
+    static createWaiting(addTimer: boolean | undefined, isTimerRunning: boolean | undefined, status: string, startingPoint: Date, stopPoint?: Date): InteractionPart;
+    static createSuspended(): InteractionPart;
+    static getPartTextContent(part: InteractionPart): string;
+    static FlatParts(parts: InteractionPart[]): InteractionPart | undefined;
+    static isCharArray(value: any): value is string[];
+    /**
+     * Detects objects like `{0: "a", 1: "b", 2: "c", ...}` — a string that was
+     * spread/indexed into an object (e.g. `{...someString}` or the server
+     * serializing a string as a char-indexed dict). Returns the reassembled
+     * string, or `null` if the value doesn't match this pattern.
+     */
+    static tryCollapseCharIndexedObject(value: any): string | null;
+    static isCodeExecution(part: InteractionPart): boolean;
+}

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

@@ -0,0 +1,10 @@
+import { IDBStorable } from './IDBStorable';
+export interface LlmSession extends IDBStorable {
+    State?: Record<string, any>;
+    LoadedInstructions: string[];
+}
+export interface LlmCreateSessionResponse {
+    sessionId: string;
+    success: boolean;
+    errorMessage: string;
+}

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

@@ -0,0 +1,48 @@
+/**
+ * Memory model - represents a semantic memory stored in MongoDB and Qdrant
+ * Mirrors the .NET Memory entity in Envision.SemanticKernel.Core/Memory/Memory.cs
+ */
+/**
+ * Context types for memories - determines how they're filtered in semantic search
+ */
+export declare enum MemoryContexts {
+    Table = 0,// Table schema information
+    Metric = 1,// Business metrics and KPIs
+    Chart = 2,// Chart/visualization descriptions
+    Dashboards = 3,// Dashboard information
+    Suggestions = 4,// Business recommendations
+    Memory = 5
+}
+/**
+ * Human-readable labels for each context type
+ */
+export declare const MemoryContextLabels: Record<MemoryContexts, string>;
+/**
+ * Full Memory entity as stored in the database
+ */
+export interface SemanticMemory {
+    id: string;
+    memoryText: string;
+    relatedTags?: string;
+    created?: string;
+    updatedAt?: string;
+    runtimeScore?: number;
+    runtimeRank?: number;
+}
+/**
+ * Input model for creating/updating memories
+ * Does not include id, created, or runtime properties
+ */
+export interface SemanticMemoryInput {
+    memoryText: string;
+    relatedTags?: string;
+}
+/**
+ * Options for semantic search
+ */
+export interface SemanticMemorySearchOptions {
+    relatedTable?: string;
+    relatedContext?: MemoryContexts;
+    relatedTags?: string;
+    limit?: number;
+}

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

@@ -0,0 +1,11 @@
+export type NotificationType = 'info' | 'warning' | 'error';
+export interface BasicNotification {
+    type: NotificationType;
+    message: string;
+    details?: string;
+}
+export interface EnvironmentNotification extends BasicNotification {
+    id: string;
+    creation: Date;
+    open?: boolean;
+}

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

@@ -0,0 +1,20 @@
+import { IDBStorable } from './IDBStorable';
+export interface Prompt extends IDBStorable {
+    id: string;
+    promptText: string;
+    promptJson?: string;
+    created: Date;
+    updatedAt?: Date;
+    lastUpdated?: Date;
+    instructions?: ScoredInstruction[];
+}
+export interface ScoredInstruction {
+    instruction: string;
+    score: number;
+    group: number;
+}
+export declare class PromptUtils {
+    static createPrompt(promptText: string, promptJson?: string): Prompt;
+    static formatTimeAgo(created: string): string;
+    static truncateText(text: string, maxLength?: number, promptNumber?: number): string;
+}

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

@@ -0,0 +1,21 @@
+import { Interaction } from './Interaction';
+export interface SendMessageResponse {
+    interaction: Interaction;
+    success: boolean;
+    error?: string;
+    firstReadPromise?: Promise<void>;
+    streamReaderPromise?: Promise<void>;
+    startStreamPromise?: Promise<StartStreamResponse> | null;
+    sendMessagePromise?: Promise<any>;
+}
+export interface StartStreamResponse {
+    success: boolean;
+    error?: string;
+}
+export interface ServerSendMessageResponse {
+    success: boolean;
+    status: string;
+    error_message?: string;
+    session_id: string;
+    call_id: string;
+}

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

@@ -0,0 +1,130 @@
+import { EventType } from './enums';
+import { InteractionPart } from './InteractionPart';
+import { EndMessageData } from './EndMessageData';
+import { ArtifactJson } from '../utils/jsonDetector';
+import { KernelContent, LlmArtifact, LlmEvent, PartType, SessionInformation, StreamingKernelContent } from './semanticKernelModel/models';
+export interface FunctionDetails {
+    id: string;
+    args?: any;
+    text?: string;
+    name: string;
+    start?: Date;
+    end?: Date;
+    response?: any;
+    status: 'Composing' | 'Executing' | 'Done';
+    silent?: boolean;
+    /** True when this targets a [KernelUiFunction] render tool — classified as `uiTool`. */
+    isUi?: boolean;
+    /** Server-provided human one-liner describing the call args, for the tool-call chip. */
+    argsDescription?: string;
+    /**
+     * Client-only payload the tool produced via its ToolClientOutput sink, correlated to this call
+     * by id. A (possibly JSON) string off the wire — render data the LLM never saw. Arrives WITH the
+     * result on the live path (StreamingFinalFunctionResultContent.clientOutput) and is folded from
+     * the persisted FunctionClientOutputContent sibling on replay. Prefer this over `args` in a
+     * uiTool renderer; it is only present once the call has RESPONDED.
+     */
+    clientOutput?: any;
+}
+export interface ThoughtDetails {
+    text: string;
+}
+export interface ToolEventDetails {
+    eventName: string;
+    eventData: string;
+    subAgentId?: string;
+    /** Id of the session that generated the event (server-stamped). Lets consumers
+     *  persist event-derived state to the right session even for stale/trailing events. */
+    sessionId?: string;
+}
+export interface TextDetails {
+    hasCodeBlock?: boolean;
+    version: number;
+}
+export interface ErrorDetails {
+    errorMessage: string;
+}
+export interface ExecutableCodeDetails {
+    code: string;
+    language: string;
+}
+export interface CodeExecutionResultDetails {
+    outcome: string;
+    output?: string;
+}
+interface CodeExecutionResult {
+    outcome: string | null;
+    output: string | null;
+}
+interface ExecutableCode {
+    code: string | null;
+    language: string | null;
+}
+interface PythonPart {
+    thought?: boolean | null;
+    code_execution_result?: CodeExecutionResult | null;
+    executable_code?: ExecutableCode | null;
+    function_call?: Partial<FunctionDetails> | null;
+    function_response?: Partial<FunctionDetails> | null;
+    text?: string | null;
+}
+export interface PythonEventMessage {
+    mime_type: string;
+    autor: string;
+    turn_complete?: boolean;
+    usage_metadata?: any;
+    end_message_data?: EndMessageData | null;
+    invocation_id?: string;
+    serverError?: string | null;
+    interrupted?: boolean | string;
+    is_final_response?: boolean;
+    session_information?: SessionInformation | null;
+    part_data?: PythonPart | null;
+    all_parts_data?: PythonPart[] | null;
+    interaction_id: string | null;
+    partial?: boolean | string;
+    artifact_generated?: ArtifactJson[];
+    async_final_response?: boolean;
+}
+export declare class ServerEvent {
+    uniqueId: string;
+    mimeType: string;
+    created: Date;
+    author: 'tool' | 'main' | 'system';
+    eventType: EventType;
+    allEventTypes: EventType[];
+    interactionId: string;
+    artifactsDelta: string[];
+    llmArtifacts?: LlmArtifact[];
+    partial: boolean;
+    turn_complete?: boolean;
+    isFinalResponse?: boolean;
+    interrupted?: boolean;
+    model_session_id: string;
+    functionDetails?: FunctionDetails;
+    executableCodeDetails?: ExecutableCodeDetails;
+    codeExecutionResultDetails?: CodeExecutionResultDetails;
+    thoughtDefails?: ThoughtDetails;
+    rawDetails?: any;
+    rendered?: boolean;
+    serverError?: string;
+    server_session_id?: string | null;
+    asyncFinalResponse?: boolean;
+    agentServerBaseUrl?: string;
+    parts: InteractionPart[];
+    endMessageData?: EndMessageData;
+    command?: string;
+    session_information?: SessionInformation;
+    subAgentId?: string;
+    subAgentName?: string;
+    visible: boolean;
+    constructor(interactionId: string);
+    static createErrorEvent(errorMessage: string, interactionId: string): ServerEvent;
+    static parseFlatPropertiesTypedEvent(event: LlmEvent): ServerEvent;
+    static getPartType(part: KernelContent | StreamingKernelContent): PartType;
+    static parseFromTypedEvent(event: LlmEvent): ServerEvent;
+    static createFromThought(interactionId: string, thinkingText: string): ServerEvent;
+    static createFromFunctionName(functionName: string, interactionId: string, callData?: any): ServerEvent;
+    static createFromText(message: string, interactionId: string, thinkingData?: string): ServerEvent;
+}
+export {};

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

@@ -0,0 +1,9 @@
+export type ConnectionState = 'Disconnected' | 'Connected' | 'Idle' | 'Paused' | 'Connecting' | 'Unknown';
+export declare const ConnectionState: {
+    readonly Disconnected: "Disconnected";
+    readonly Connected: "Connected";
+    readonly Paused: "Paused";
+    readonly Idle: "Idle";
+    readonly Connecting: "Connecting";
+    readonly Unknown: "Unknown";
+};

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

@@ -0,0 +1,33 @@
+import { Customer } from './Customer';
+import { Agent } from './Agent';
+import { IDBStorable } from './IDBStorable';
+export declare class Account {
+    id: string;
+    biName: string;
+    constructor(id: string, biName: string);
+    getBiName(): string;
+}
+export interface User extends IDBStorable {
+    email: string;
+    family_name: string;
+    given_name: string;
+    name: string;
+    hd: string;
+    picture: string;
+    access_token: string;
+    previous_access_token?: string;
+    refresh_token?: string;
+    account?: Account;
+}
+export interface AuthState {
+    isAuthenticated: boolean;
+    isLoading: boolean;
+    login: (userData: User) => void;
+    logout: () => void;
+    errorMessage: string | null;
+}
+export interface AgentContext {
+    agentConfig: Partial<Agent>;
+    customer?: Customer;
+    model?: string;
+}