@aintela/chat 0.2.15

package/dist/src/services/servers/AgentGatewayService.d.ts

@@ -0,0 +1,167 @@
+import { ServerEvent, ToolEventDetails } from '../../models/ServerEvent';
+import { User, AgentContext } from '../../models/contexts';
+import { ClientMessage } from '../../models/ClientMessage';
+import { Interaction, MergeResult } from '../../models/Interaction';
+import { EventBusService, FirstTokenEventDetails } from '../eventBusService';
+import { InteractionService } from '../interactionService';
+import { RunMode } from '../../models/enums';
+import { InteractionPart } from '../../models/InteractionPart';
+import { StartStreamResponse, SendMessageResponse } from '../../models/SendMessageResponse';
+import { IArtifactService } from '../interfaces/artifactService';
+import { Artifact } from '../../models/Artifact';
+import { AiChatState, AiChatStore } from '../../components/AiChat/stateConfiguration';
+import { INotificationPort } from '../../interfaces/INotificationPort';
+import { EndMessageData } from '../../models/EndMessageData';
+import { IStorageService } from '../storageService';
+export interface GatewaySendMessageOptions {
+    callId?: string;
+}
+export declare abstract class AgentGatewayService {
+    base_production_url: string;
+    base_url_local: string;
+    base_url: string;
+    isLocal: boolean;
+    msg_order: number;
+    static SUSPENSION_MSG: string;
+    protected lastPing: Date;
+    protected interactionsMap: Map<string, Interaction>;
+    protected interactionsServiceMap: Map<string, InteractionService>;
+    protected user: User;
+    protected config: AgentContext;
+    protected currentIS: InteractionService | null;
+    protected server_session_id?: string | null;
+    protected model_session_id?: string | null;
+    protected runMode: RunMode;
+    protected sessionState: AiChatState;
+    protected storageService: IStorageService;
+    protected notificationPort: INotificationPort;
+    protected interactionCallIds: Map<string, string>;
+    protected rawJwt: string;
+    protected sessionId?: string;
+    isInited: boolean;
+    eventBusService: EventBusService;
+    artifactService: IArtifactService;
+    onTurnOpen: (listener: (...args: any[]) => Promise<void>) => void;
+    offTurnOpen: (listener: (...args: any[]) => Promise<void>) => void;
+    onTurnComplete: (listener: (...args: any[]) => Promise<void>) => void;
+    offTurnComplete: (listener: (...args: any[]) => Promise<void>) => void;
+    onStreamError: (listener: (...args: any[]) => Promise<void>) => void;
+    offStreamError: (listener: (...args: any[]) => Promise<void>) => void;
+    onStreamEnded: (listener: (...args: any[]) => Promise<void>) => void;
+    offStreamEnded: (listener: (...args: any[]) => Promise<void>) => void;
+    onMessage: (listener: (...args: any[]) => Promise<void>) => void;
+    offMessage: (listener: (...args: any[]) => Promise<void>) => void;
+    onFirstToken: (listener: (details: FirstTokenEventDetails) => Promise<void>) => void;
+    offFirstToken: (listener: (details: FirstTokenEventDetails) => Promise<void>) => void;
+    onEndMessageData(listener: (data: EndMessageData) => Promise<void>): void;
+    offEndMessageData(listener: (data: EndMessageData) => Promise<void>): void;
+    onFunctionResponse: (listener: (...args: any[]) => Promise<void>) => void;
+    offFunctionResponse: (listener: (...args: any[]) => Promise<void>) => void;
+    toolSessionId: string | null;
+    /**
+     * Send the user's answer to a parked `ask_user` tool call back to the agent.
+     * Default no-op; the WebSocket gateway (AgentGatewayWSAsync) overrides it to emit
+     * a ChatAction.AnswerHumanTool frame.
+     */
+    answerHumanTool(toolCallId: string, answer: string): void;
+    constructor(user: User, eventBusService: EventBusService, artifactService: IArtifactService, baseUrl: string, config: AgentContext, sessionStore: AiChatStore, notificationPort: INotificationPort, storageService: IStorageService, sessionId?: string, runMode?: RunMode);
+    getAgentContext(): AgentContext;
+    getModel(): string | undefined;
+    setModel(modelId: string): void;
+    /**
+     * Live update for the agent / customer slice of the gateway's
+     * config. Mirrors {@link setModel}'s in-place pattern so the
+     * next outgoing message — `sendMessageInternal` reads
+     * `this.config.agentConfig?.id` directly at send time, see
+     * `AgentGatewayWSAsync.sendMessageInternal` — picks up the new
+     * id without rebuilding the gateway or tearing down the
+     * WebSocket. This is what the host calls from the agent picker
+     * so switching agents preserves the current session's
+     * connection, chat history, and any in-flight stream state
+     * instead of remounting `AiChatProvider` and losing them.
+     *
+     * Callers should pass the FULL replacement context (the same
+     * shape they originally constructed the gateway with). The
+     * gateway preserves the `model` slice from its current config
+     * if the incoming context omits it — the model is owned
+     * separately by `setModel` and shouldn't get clobbered by an
+     * agent-only change.
+     */
+    setAgentContext(config: AgentContext): void;
+    getSessionId(): string | undefined;
+    getErrorEvent(errorMessage: string): {
+        interaction_id: string | null;
+        model_session_id: string;
+        mime_type: string;
+        partial: boolean;
+        serverError: string;
+    };
+    setSession(sessionId: string, toolSessionId: string): void;
+    startInteraction(interactionQuestion: string, wasSuspended?: boolean | undefined, idOverrideForTests?: string): Interaction;
+    getInteractions(): Interaction[];
+    getRecentInteractions(filterMs?: number): Interaction[];
+    protected updateMap(serverEvent: ServerEvent): MergeResult | undefined;
+    getCurrentInteractionId(): string | null;
+    getCurrentInteraction(): Interaction | null;
+    getInteraction(interactionId: string): Interaction | undefined;
+    hasState(): boolean;
+    protected buildAgentParams(): string;
+    abstract finalResponse(interactionId: string, agentInteraction: Interaction, author: string, subAgentId?: string): void;
+    openConnection(sessionId?: string): Promise<string>;
+    abstract closeConnection(closeTurn: boolean): Promise<SendMessageResponse | null>;
+    protected Error(errorMessage?: string | undefined): Promise<void>;
+    private pendingCurrentMessage;
+    private lastCurrentMessageUpdate;
+    private static readonly CURRENT_MSG_THROTTLE_MS;
+    hasServerSessionId(): boolean;
+    runningRequests: Map<string, Promise<Artifact | null>>;
+    asyncLoadArtifact(artifactId: string): Promise<Artifact | null>;
+    protected processComands(serverEvent: ServerEvent): boolean;
+    lastToolInteraction: string;
+    protected subAgentInteractions: Map<string, Interaction>;
+    protected subAgentInteractionServices: Map<string, InteractionService>;
+    protected getOrCreateSubAgentInteraction(subAgentId: string, interactionId: string, subAgentName?: string): {
+        interaction: Interaction;
+        service: InteractionService;
+    };
+    protected handleSubAgentEvent(serverEvent: ServerEvent): void;
+    Message(event: MessageEvent | ServerEvent): Promise<void>;
+    hasOneCompleteInteraction(): boolean;
+    protected localEmitToolEvent(toolDetails: ToolEventDetails): void;
+    protected registerInteractionCallId(interactionId: string, options?: GatewaySendMessageOptions): void;
+    protected localEmitFirstToken(interactionId: string): void;
+    private lastThorttledTimeout;
+    private doEmitMessage;
+    protected localEmitMessage(message: Interaction, mergeResult?: MergeResult): void;
+    protected localOpen(interactionId: string, _author: string): void;
+    /**
+     * Drop any throttled `currentMessage` emit still queued by
+     * `localEmitMessage`. The throttle's trailing edge is a `setTimeout` that
+     * calls `setCurrentMessage(...)`; if it fires *after* the turn has been
+     * committed (`setNewMessage` moved the interaction into `messages` and
+     * nulled `currentMessage`), it re-publishes the now-committed interaction
+     * as the live message — so the chat renders the turn twice: once in
+     * history (`MessageAgent` with `onGoing=false`, which drops Thought parts)
+     * and once as the live `currentMessage` (`onGoing=true`, which keeps them).
+     * That is the duplicated-bubble bug (the two copies even look different —
+     * only the live one shows the "thought" strip). Call this on turn commit.
+     */
+    private cancelPendingCurrentMessage;
+    protected turnComplete(interactionId: string, agentInteraction: Interaction, _author: string, subAgentId?: string): Promise<void>;
+    protected lastPingStatus: boolean;
+    protected handlePing(): Promise<boolean>;
+    sendMessage(message: ClientMessage, options?: GatewaySendMessageOptions): Promise<SendMessageResponse>;
+    abstract startStream(sendStartMessage?: boolean): Promise<StartStreamResponse>;
+    abstract stopStream(): void;
+    abstract sendMessageInternal(message: ClientMessage, options?: GatewaySendMessageOptions): Promise<SendMessageResponse>;
+    abstract isSuspended(): boolean;
+    abstract suspend(): Promise<boolean>;
+    abstract reset(user: User, config?: AgentContext): void;
+    check(): Promise<boolean>;
+    startAndForget(): void;
+    forceReceiveMessage(serverEvent: ServerEvent): void;
+    sendStatusMessage(question: string, parts: InteractionPart[], interactionId: string): void;
+    clearStatus(): void;
+    ping(): Promise<boolean>;
+    protected getNewInteractionId(): string;
+}

package/dist/src/services/servers/AgentGatewayWSAsync.d.ts

@@ -0,0 +1,44 @@
+import { User, AgentContext } from '../../models/contexts';
+import { ClientMessage } from '../../models/ClientMessage';
+import { AgentGatewayService, GatewaySendMessageOptions } from './AgentGatewayService';
+import { Interaction } from '../../models/Interaction';
+import { EventBusService } from '../eventBusService';
+import { SendMessageResponse, StartStreamResponse } from '../../models/SendMessageResponse';
+import { IArtifactService } from '../interfaces/artifactService';
+import { AxiosResponse } from 'axios';
+import { IHeartbeatPort } from '../../interfaces/IHeartbeatPort';
+import { INotificationPort } from '../../interfaces/INotificationPort';
+import { ConnectionState } from '../../models/connectionState';
+import { AiChatStore } from '../../components/AiChat/stateConfiguration';
+import { IWebSocketConnection } from '../WebSocketConnection/webSocketConnection';
+import { IStorageService } from '../storageService';
+export type Reader = (response: AxiosResponse, wasSuspended: boolean, onFirstRead?: () => void) => void;
+export declare class AgentGatewayWSAsync extends AgentGatewayService {
+    suspendState: boolean;
+    reset(_user: User, _config?: AgentContext): void;
+    startStream(_sendStartMessage?: boolean): Promise<StartStreamResponse>;
+    isSuspended(): boolean;
+    protected wsService: IWebSocketConnection;
+    protected root_url: string;
+    protected hearBeatPort?: IHeartbeatPort;
+    connectionAttempts: number;
+    constructor(user: User, eventBusService: EventBusService, artifactService: IArtifactService, baseUrl: string, config: AgentContext, sessionStore: AiChatStore, notificationPort: INotificationPort, ws: IWebSocketConnection, storageService: IStorageService, heartbeatPort?: IHeartbeatPort, sessionId?: string);
+    getStoredSessionId(): string | undefined;
+    isInteractionComplete(interactionId: string): boolean | undefined;
+    isTurnCompleted(interactionId: string): boolean | undefined;
+    statuses: string[];
+    finalResponse(interactionId: string, agentInteraction: Interaction, author: string): Promise<void>;
+    stopStream(closeTurn?: boolean): void;
+    suspend(): Promise<boolean>;
+    answerHumanTool(toolCallId: string, answer: string): void;
+    cancelSuspend(): Promise<void>;
+    check(): Promise<boolean>;
+    lastConnectionPromise: Promise<string> | null;
+    socketState: ConnectionState;
+    openConnection(sessionId?: string): Promise<string>;
+    closeConnection(closeTurn?: boolean): Promise<SendMessageResponse | null>;
+    simulateDisconnect(code?: number, reason?: string): void;
+    sleep(ms: number): Promise<unknown>;
+    streamOpened: boolean;
+    sendMessageInternal(message: ClientMessage, options?: GatewaySendMessageOptions, _openTurn?: boolean): Promise<SendMessageResponse>;
+}

package/dist/src/services/servers/agentGatewayWSAsync.test.d.ts

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

package/dist/src/services/servers/sessionService/ISessionService.d.ts

@@ -0,0 +1,20 @@
+import { ChatSession } from '../../../models/ChatSession';
+import { Customer } from '../../../models/Customer';
+import { ServerResponse } from '../../../models/serverReponse';
+import { LlmCreateSessionResponse, LlmSession } from '../../../models/LlmSession';
+export interface ISessionService {
+    getAllSessions(): Promise<ChatSession[]>;
+    removeSession(sessionId: string): Promise<void>;
+    getLlmSessionInformation(): Promise<LlmSession>;
+    retrieveSession(sessionId: string): Promise<ChatSession | null>;
+    createSession(sessionId: string, agentName: string, customer?: Customer): Promise<ChatSession | null>;
+    createAgentSession(): Promise<LlmCreateSessionResponse>;
+    closeSession(sessionId: string): Promise<void>;
+    generateOverviewForCurrentSession(systemInstruction: string, model: string): Promise<string | null>;
+    storeSession(session: ChatSession): Promise<ServerResponse<ChatSession>>;
+    patchSession(sessionId: string, partialChatSession: Partial<ChatSession>): Promise<void>;
+    delayedPatchActiveSession(partialChatSession: Partial<ChatSession>): void;
+    patchActiveSession(partialChatSession: Partial<ChatSession>): Promise<ChatSession | null>;
+    getLastUsedSession(): Promise<ChatSession | null>;
+    transformIntoInstances(session: ChatSession): ChatSession;
+}

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

@@ -0,0 +1,22 @@
+import { Interaction } from '../models/Interaction';
+/**
+ * Rebuilds the `Interaction[]` the chat UI renders from the historical event
+ * log returned by <c>GET /sessions/{id}</c>.
+ *
+ * Unlike the live turn loop, this does NOT route events through
+ * `InteractionService.merge`. The merge pipeline (and its `FlatParts` step) is
+ * built for the *live* stream, where each event carries a single content item
+ * arriving incrementally; it flattens every event down to one part. The
+ * *persisted* log is different: the server stores consolidated blocks where a
+ * single event's `content.items` holds many parts at once — e.g. a text
+ * preamble plus several FunctionCalls. Running those through `merge` collapsed
+ * each event to one part and silently dropped the rest (every function call in
+ * a multi-item event disappeared on replay).
+ *
+ * This restore path instead reads *every* item as its own `InteractionPart`
+ * (via `ServerEvent.parseFromTypedEvent`, which already maps one part per
+ * item) and only applies the one piece of merge logic replay genuinely needs:
+ * folding each FunctionResponse onto the call it answers, keyed by `callId`.
+ * No copy-on-write cloning, no event-bus side effects, no streaming-append.
+ */
+export declare function decodeSessionEvents(rawEvents: unknown[]): Interaction[];

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

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

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

@@ -0,0 +1,73 @@
+import { ArtifactData, Section } from '../models/ArtifactData';
+import { Prompt } from '../models/Prompt';
+export interface IStorageService {
+    initializeStorage(): void;
+    getSections(): Section[];
+    getArtifacts(): ArtifactData[];
+    createSection(name: string, iconType?: 'dashboard' | 'chart' | 'folder'): Section;
+    updateSection(sectionId: string, updates: Partial<Section>): void;
+    deleteSection(sectionId: string): void;
+    storeArtifact(artifact: ArtifactData): void;
+    moveArtifact(artifactId: string, newSectionId: string): void;
+    deleteArtifact(artifactId: string): void;
+    updateArtifact(artifactId: string, updates: Partial<ArtifactData>): void;
+    getArtifactsBySection(sectionId: string): ArtifactData[];
+    getPrompts(): Prompt[];
+    storePrompt(prompt: Prompt): void;
+    deletePrompt(promptId: string): void;
+    clearAllPrompts(): void;
+    getItem(key: string): any;
+    setItem(key: string, value: any): void;
+    removeItem(key: string): void;
+}
+export declare class LocalStorageService implements IStorageService {
+    getItem(key: string): string | null;
+    setItem(key: string, value: any): void;
+    removeItem(key: string): void;
+    onPromptCreated: (prompt: Prompt) => void;
+    initializeStorage(): void;
+    getSections(): Section[];
+    getArtifacts(): ArtifactData[];
+    createSection(name: string, iconType?: 'dashboard' | 'chart' | 'folder'): Section;
+    updateSection(sectionId: string, updates: Partial<Section>): void;
+    deleteSection(sectionId: string): void;
+    storeArtifact(artifact: ArtifactData): void;
+    moveArtifact(artifactId: string, newSectionId: string): void;
+    deleteArtifact(artifactId: string): void;
+    updateArtifact(artifactId: string, updates: Partial<ArtifactData>): void;
+    getArtifactsBySection(sectionId: string): ArtifactData[];
+    getPrompts(): Prompt[];
+    storePrompt(prompt: Prompt): void;
+    deletePrompt(promptId: string): void;
+    clearAllPrompts(): void;
+}
+export declare class MockStorageService implements IStorageService {
+    getItem(_key: string): string;
+    setItem(_key: string, _value: any): void;
+    removeItem(_key: string): void;
+    private artifacts;
+    private sections;
+    private prompts;
+    onPromptCreated: (prompt: Prompt) => void;
+    setMockArtifacts(artifacts: ArtifactData[]): void;
+    setMockSections(sections: Section[]): void;
+    setMockPrompts(prompts: Prompt[]): void;
+    initializeStorage(): void;
+    getSections(): Section[];
+    getArtifacts(): ArtifactData[];
+    createSection(name: string, iconType?: 'dashboard' | 'chart' | 'folder'): Section;
+    updateSection(sectionId: string, updates: Partial<Section>): void;
+    deleteSection(sectionId: string): void;
+    storeArtifact(artifact: ArtifactData): void;
+    moveArtifact(artifactId: string, newSectionId: string): void;
+    deleteArtifact(artifactId: string): void;
+    updateArtifact(artifactId: string, updates: Partial<ArtifactData>): void;
+    getArtifactsBySection(sectionId: string): ArtifactData[];
+    getPrompts(): Prompt[];
+    storePrompt(prompt: Prompt): void;
+    deletePrompt(promptId: string): void;
+    clearAllPrompts(): void;
+}
+export declare const usePromptState: (storageService: IStorageService) => {
+    promptState: string;
+};

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

@@ -0,0 +1,3 @@
+export { v2Theme } from './v2';
+export type { V2Theme } from './v2';
+export { V2_CHART_PALETTE } from './v2-chart-palette';

package/dist/src/themes/v2-chart-palette.d.ts

@@ -0,0 +1 @@
+export declare const V2_CHART_PALETTE: readonly string[];

package/dist/src/themes/v2.d.ts

@@ -0,0 +1,71 @@
+export declare const themeTokens: {
+    readonly bgCanvas: "#0a0a0b";
+    readonly bgCanvasTransparency: "#0a0a0bDD";
+    readonly bgPanel: "#111114";
+    readonly bgRaised: "#17171b";
+    readonly bgHover: "#1d1d22";
+    readonly border: "#26262d";
+    readonly borderSoft: "#1f1f25";
+    readonly divider: "#161616";
+    readonly text: "#ececef";
+    readonly textDim: "#8e8e96";
+    readonly textFaint: "#5a5a62";
+    readonly accent: "#e0a458";
+    readonly accentDim: "#7a5a30";
+    readonly accentSoft: "rgba(224,164,88,0.14)";
+    readonly good: "#5eb88a";
+    readonly bad: "#d97a7a";
+    readonly font: "\"Inter\", -apple-system, BlinkMacSystemFont, \"Segoe UI\", system-ui, sans-serif";
+    readonly mono: "\"JetBrains Mono\", ui-monospace, SFMono-Regular, Menlo, monospace";
+    readonly radius: 10;
+    readonly radiusSm: 6;
+    readonly radiusLg: 12;
+};
+declare module '@mui/material/styles' {
+    interface Palette {
+        surface: {
+            panel: string;
+            raised: string;
+            hover: string;
+            chrome?: string;
+            chromePanel?: string;
+        };
+        border: {
+            default: string;
+            soft: string;
+        };
+    }
+    interface PaletteOptions {
+        surface?: {
+            panel: string;
+            raised: string;
+            hover: string;
+            chrome?: string;
+            chromePanel?: string;
+        };
+        border?: {
+            default: string;
+            soft: string;
+        };
+    }
+    interface PaletteColor {
+        softBg?: string;
+    }
+    interface SimplePaletteColorOptions {
+        softBg?: string;
+    }
+    interface TypographyVariants {
+        fontFamilyMono: string;
+    }
+    interface TypographyVariantsOptions {
+        fontFamilyMono?: string;
+    }
+}
+declare module '@mui/system' {
+    interface Shape {
+        radiusSm: number;
+        radiusLg: number;
+    }
+}
+export declare const v2Theme: import('@mui/material').Theme;
+export type V2Theme = typeof v2Theme;

package/dist/src/utils/auth.d.ts

@@ -0,0 +1,9 @@
+export declare const GOOGLE_CLIENT_ID: string | undefined;
+export declare const ALLOWED_DOMAINS: string[];
+export declare const ALLOWED_EMAILS: string[];
+export declare const AUTH_CONFIG: {
+    requireAuthentication: boolean;
+    allowAnonymousAccess: boolean;
+    sessionTimeout: number;
+    GOOGLE_API_KEY: string | undefined;
+};

package/dist/src/utils/envOverrides.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Deployment-URL overrides (e.g. a staging environment), resolved per environment:
+ *
+ * - Node (SSR / tests): real environment variables, read at call time.
+ * - Browser: `process` doesn't exist. The HOST app's Vite build statically
+ *   replaces these exact `process.env.X` member expressions via `define`
+ *   (see envision-abi dashboard-app vite.config.ts — the same channel it
+ *   already uses for `process.env.MODE`). Without such a define the read
+ *   throws on the bare `process` global → caught → no override.
+ *
+ * NOTE: `import.meta.env.VITE_*` is NOT usable here — this package builds in
+ * Vite lib mode, which inlines `import.meta.env` at PACKAGE build time, so a
+ * consumer's VITE_* values can never reach the published dist. `process.env.X`
+ * member expressions survive the lib build, which is what makes the consumer
+ * `define` channel work.
+ *
+ * The reads must stay literal static member accesses (no dynamic key lookup),
+ * or the consumer's define replacement won't match them.
+ */
+/** Base URL of the .NET agent server (overrides `https://agent.tripapi.com.br`). */
+export declare function agentBaseUrlOverride(): string | undefined;
+/** Public base URL of the dashboard client app (overrides `https://client-agent.tripapi.com.br`). */
+export declare function clientBaseUrlOverride(): string | undefined;

package/dist/src/utils/envUtils.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Environment utilities for cross-platform (browser/Node.js) environment variable access
+ */
+export declare function getEnvVar(key: string): string | undefined;
+export declare function isViteEnvironment(): boolean;
+export declare function isNodeEnvironment(): boolean;
+export declare function getRandomUUID(): string;
+declare const _default: {
+    getEnvVar: typeof getEnvVar;
+    isViteEnvironment: typeof isViteEnvironment;
+    isNodeEnvironment: typeof isNodeEnvironment;
+};
+export default _default;

package/dist/src/utils/environmentUtils.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Environment detection and URL resolution utilities
+ * Provides different base URLs for client vs server-side execution
+ */
+export declare const DEV_SERVER_CONFIG: {
+    readonly SERVER_BASE_URL: "http://localhost:3000";
+    readonly CLIENT_BASE_URL: "http://localhost:5800";
+    readonly CUSTOM_HEADERS: {};
+};
+export declare const ANALYTICS_AGENT_NAME = "analytics_agent";
+/**
+ * Detects if code is running in browser vs server environment
+ */
+export declare function isBrowser(): boolean;
+/**
+ * Detects if code is running in Node.js server environment
+ */
+export declare function isServer(): boolean;
+/**
+ * Gets the appropriate base URL for API calls
+ * - Browser: Returns empty string (uses relative URLs)
+ * - Server: Returns full localhost URL
+ */
+export declare function getServerBaseAbUrl(): string;
+export declare function getServerBaseUrl(): string;
+export declare function getServerClientBaseUrl(): string;
+export declare function getAgentServerBaseUrl(): string;
+/**
+ * Resolves a relative API path to full URL when needed
+ * @param relativePath - API path like "/api/sessions"
+ * @returns Full URL for server, relative path for browser
+ */
+export declare function resolveApiUrl(relativePath: string): string;
+/**
+ * Gets environment info for debugging
+ */
+export declare function getEnvironmentInfo(): {
+    isBrowser: boolean;
+    isServer: boolean;
+    baseUrl: string;
+    userAgent: string;
+    nodeVersion: string;
+};

package/dist/src/utils/fileUtils.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Normalizes a filename by removing special characters
+ * @param text - The input text to normalize
+ * @returns The normalized text
+ */
+export declare function normalizeFilename(text: string): string;

package/dist/src/utils/getAgentArtifactsBaseUrl.d.ts

@@ -0,0 +1 @@
+export declare const getArtifactsBaseUrl: () => string;

package/dist/src/utils/getAgentBaseUrl.d.ts

@@ -0,0 +1 @@
+export declare const getAgentBaseUrl: (window: any) => string;

package/dist/src/utils/getDotNetBaseUrl.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Gets the base URL for the .NET backend API
+ * Used for Agent and Plugin services that communicate directly with the .NET server
+ */
+export declare function getDotNetBaseUrl(): string;

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

@@ -0,0 +1,17 @@
+export { getServerBaseUrl, isServer, ANALYTICS_AGENT_NAME, getAgentServerBaseUrl, DEV_SERVER_CONFIG, getServerClientBaseUrl, getEnvironmentInfo, resolveApiUrl, } from './environmentUtils';
+export { getAgentBaseUrl } from './getAgentBaseUrl';
+export { getArtifactsBaseUrl } from './getAgentArtifactsBaseUrl';
+export { getDotNetBaseUrl } from './getDotNetBaseUrl';
+export { getRandomUUID, getEnvVar } from './envUtils';
+export { dateReviver } from './objectUtils';
+export { extractLinkAction, parseAndValidateArtifactUrl } from './urlParser';
+export { parseKnownNumbers, chunkArray, splitBigLinesWithSpaces } from './stringUtils';
+export { parseArtifactFromJson } from './parseArtifact';
+export { decodeBase64, encodeBase64, decodeUriFromPython, isBase64Encoded } from './jsonDetector';
+export { isUriEncoded, decodeUri, encodeUri, isValidUri, parseUriParams } from './uriUtils';
+export { startsWithInteractionId, extractInteractionId, isValidInteractionId, } from './interactionIdChecker';
+export { setEbiContextSessionId, setEbiContextData } from './sessionWindowParameters';
+export { default as materialIcons, getIconByName, searchIcons, iconCategories, } from './materialIconsList';
+export type { MaterialIcon } from './materialIconsList';
+export { GOOGLE_CLIENT_ID, ALLOWED_DOMAINS, ALLOWED_EMAILS, AUTH_CONFIG } from './auth';
+export { default as SortableTable } from './sortable-table';

package/dist/src/utils/interactionIdChecker.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Utility function to check if a string starts with an interaction ID (UUID)
+ * Supports both formats:
+ * - With dashes: ebd067ef-0dbd-49b3-8eff-c54b2a9ff314
+ * - Without dashes: 62ec037ae42c439192c64dd112136583
+ */
+/**
+ * Check if a string starts with an interaction ID (UUID)
+ * @param str - The string to check
+ * @returns true if the string starts with a valid UUID, false otherwise
+ */
+export declare function startsWithInteractionId(str: string): boolean;
+/**
+ * Extract the interaction ID from the beginning of a string
+ * @param str - The string to extract from
+ * @returns The interaction ID if found, null otherwise
+ */
+export declare function extractInteractionId(str: string): string | null;
+export declare function prettiffyFileName(fileName: string): string;
+export declare function prettiffyPythonFunctionName(functionName: string): string;
+export declare function extractNameFromStringWithInteractionId(str: string): string;
+/**
+ * Check if a string is a valid interaction ID (UUID) on its own
+ * @param str - The string to check
+ * @returns true if the string is a valid UUID, false otherwise
+ */
+export declare function isValidInteractionId(str: string): boolean;

package/dist/src/utils/jsonDetector.d.ts

@@ -0,0 +1,50 @@
+import { ArtifactType } from '../models/enums';
+export interface ArtifactJson {
+    description?: string;
+    reasoning?: string;
+    type?: ArtifactType;
+    file_name?: string;
+    mime_type?: string;
+    data?: string;
+}
+export declare function decodeBase64(base64: string): string;
+export declare function encodeBase64(base64: string): string;
+export declare function decodeUriFromPython(uriEncoded: string): string;
+export declare function isBase64Encoded(base64: string): boolean;
+/**
+ * Checks if a string contains a valid JSON document with the specified signature
+ * @param text - The text to check for JSON content
+ * @param signature - The expected JSON structure (optional, defaults to ArtifactSignature)
+ * @returns Object with success status and parsed data if found
+ */
+export declare function detectAndParseJson<T = ArtifactJson>(text: string): {
+    success: boolean;
+    data?: T;
+    error?: string;
+};
+/**
+ * Validates if an object matches the expected signature
+ * @param obj - The parsed JSON object
+ * @param signature - The expected structure
+ * @returns True if the object matches the signature
+ */
+/**
+ * Enhanced version that also looks for partial JSON (useful for streaming)
+ * @param text - The text to check
+ * @returns Object with success status, parsed data, and whether it's complete
+ */
+export declare function detectPartialJson<T = ArtifactJson>(text: string): {
+    success: boolean;
+    data?: T;
+    isComplete: boolean;
+    error?: string;
+};
+/**
+ * Strips all JSON documents from a string, leaving only non-JSON content
+ * @param text - The text to process
+ * @returns The text with all JSON documents removed
+ */
+export declare function stripJsonDocuments(text: string): {
+    beforeText: string;
+    afterText: string;
+};

package/dist/src/utils/jsonUtils.d.ts

@@ -0,0 +1 @@
+export declare function safeStringify(obj: any): string;