@aintela/chat 0.2.15

package/dist/src/components/AiChat/ChatPane/FriendlyPartDisplay.d.ts

@@ -0,0 +1,13 @@
+import { default as React } from 'react';
+import { FriendlyState } from './friendlyToolConfig';
+interface FriendlyPartDisplayProps {
+    toolName: string;
+    state: FriendlyState;
+    args?: any;
+    isError?: boolean;
+    startTime?: Date;
+    endTime?: Date;
+    streamedBytes?: number;
+}
+declare const FriendlyPartDisplay: React.FC<FriendlyPartDisplayProps>;
+export default FriendlyPartDisplay;

package/dist/src/components/AiChat/ChatPane/LastPrompts.d.ts

@@ -0,0 +1,9 @@
+import { default as React } from 'react';
+interface LastPromptsProps {
+    onPromptSelected: (promptText: string, promptJson?: string) => void;
+    forceExpanded?: number;
+    cancelTimeout: () => void;
+    children?: React.ReactNode;
+}
+declare const LastPrompts: React.FC<LastPromptsProps>;
+export default LastPrompts;

package/dist/src/components/AiChat/ChatPane/Message.d.ts

@@ -0,0 +1,11 @@
+import { default as React } from 'react';
+import { Interaction } from '../../../models/Interaction';
+interface MessageProps {
+    message: Interaction;
+    onLinkClicked: (link: string, content: string | null) => void;
+    appendWaitingPart: boolean;
+    messagesRef?: React.RefObject<Map<string, HTMLDivElement>>;
+    friendlyMode?: boolean;
+}
+declare const Message: React.FC<MessageProps>;
+export default Message;

package/dist/src/components/AiChat/ChatPane/MessageAgent.d.ts

@@ -0,0 +1,16 @@
+import { default as React } from 'react';
+import { Interaction } from '../../../models/Interaction';
+interface MessageAgentProps {
+    message: Interaction;
+    onGoing: boolean;
+    onLinkClicked: (link: string, content: string | null) => void;
+    appendWaitingPart: boolean;
+    messagesRef?: React.RefObject<Map<string, HTMLDivElement>>;
+    isConnectionOpen: boolean;
+    showSubAgents?: boolean;
+    preview: boolean;
+    container: string;
+    friendlyMode?: boolean;
+}
+declare const MessageAgent: React.FC<MessageAgentProps>;
+export default MessageAgent;

package/dist/src/components/AiChat/ChatPane/MessageNonTextDisplay.d.ts

@@ -0,0 +1,16 @@
+import { default as React } from 'react';
+import { InteractionPart } from '../../../models/InteractionPart';
+interface MessageNonTextDisplayProps {
+    title: string;
+    icon: React.ReactNode;
+    elapsed?: number;
+    content?: string;
+    part: InteractionPart;
+    sessionId: string;
+    onLinkClicked: (link: string, content: string | null) => void;
+    onDrawCodeBlock: (code: string, className: string) => React.ReactNode;
+    isLastInlineInGroup?: boolean;
+    preview?: boolean;
+}
+declare const MessageNonTextDisplay: React.FC<MessageNonTextDisplayProps>;
+export default MessageNonTextDisplay;

package/dist/src/components/AiChat/ChatPane/MessagePart.d.ts

@@ -0,0 +1,15 @@
+import { default as React } from 'react';
+import { PartRendererProps } from './parts';
+/**
+ * Dispatcher: maps a part's event type to a renderer kind and forwards
+ * props to that renderer. Per-kind components live in `./parts/`.
+ *
+ * The consumer override hook reads `partRenderers` off the AiChat services
+ * context (set via `<AiChat partRenderers={...} />`). When no override is
+ * provided for a given kind, the built-in `DEFAULT_PART_RENDERERS[kind]`
+ * renders. Used outside an AiChatProvider, the dispatcher silently falls
+ * back to the built-ins — `useContext` returns undefined rather than
+ * throwing, so this stays usable for isolated rendering / tests.
+ */
+declare const MessagePart: React.FC<PartRendererProps>;
+export default MessagePart;

package/dist/src/components/AiChat/ChatPane/MessagePersona.d.ts

@@ -0,0 +1,13 @@
+import { default as React } from 'react';
+import { Interaction } from '../../../models/Interaction';
+interface MessagePersonaProps {
+    isUser: boolean;
+    message: Interaction;
+}
+/**
+ * Persona header row above a message — an avatar + "{NAME} · {time}". Rendered only when the host
+ * enables `showPersona`. The label/initials come from `resolvePersona` (default: generic
+ * "Você" / "Agente") and the time from `formatTimestamp(message.created)` (default: locale HH:mm).
+ */
+declare const MessagePersona: React.FC<MessagePersonaProps>;
+export default MessagePersona;

package/dist/src/components/AiChat/ChatPane/MessageUser.d.ts

@@ -0,0 +1,8 @@
+import { default as React } from 'react';
+import { Interaction } from '../../../models/Interaction';
+interface MessageUserProps {
+    message: Interaction;
+    onLinkClicked?: (link: string, content: string | null) => void;
+}
+declare const MessageUser: React.FC<MessageUserProps>;
+export default MessageUser;

package/dist/src/components/AiChat/ChatPane/ModelSelector.d.ts

@@ -0,0 +1,11 @@
+import { default as React } from 'react';
+interface ModelSelectorProps {
+    /**
+     * Render the model list inline (no IconButton trigger, no popover)
+     * — used by surfaces that already host their own settings menu and
+     * want the model list embedded directly. Defaults to `false`.
+     */
+    inline?: boolean;
+}
+declare const ModelSelector: React.FC<ModelSelectorProps>;
+export default ModelSelector;

package/dist/src/components/AiChat/ChatPane/Prompt.d.ts

@@ -0,0 +1,9 @@
+import { default as React } from 'react';
+interface PromptProps {
+    forceMessage?: string | null;
+    prompt?: string;
+    isTurnOpen?: boolean;
+    onHeightChange?: (newHeight: number) => void;
+}
+declare const Prompt: React.FC<PromptProps>;
+export default Prompt;

package/dist/src/components/AiChat/ChatPane/SessionDataDialog.d.ts

@@ -0,0 +1,7 @@
+import { default as React } from 'react';
+interface SessionDataDialogProps {
+    open: boolean;
+    onClose: () => void;
+}
+declare const SessionDataDialog: React.FC<SessionDataDialogProps>;
+export default SessionDataDialog;

package/dist/src/components/AiChat/ChatPane/StickyQuestionHeader.d.ts

@@ -0,0 +1,7 @@
+import { default as React } from 'react';
+interface StickyQuestionHeaderProps {
+    messageRefs: React.RefObject<Map<string, HTMLDivElement>>;
+    showStickyHeader?: boolean;
+}
+declare const StickyQuestionHeader: React.FC<StickyQuestionHeaderProps>;
+export default StickyQuestionHeader;

package/dist/src/components/AiChat/ChatPane/StreamStatistics.d.ts

@@ -0,0 +1,32 @@
+import { default as React } from 'react';
+/**
+ * Optional inline Pause / Stop control mounted at the right end of the
+ * stats row. When `pauseControl` is provided, StreamStatistics shows a
+ * single state-driven button instead of a separate footer:
+ *
+ *   - turnOpen=false                → disabled Pause icon
+ *   - turnOpen=true, suspended=false → Pause icon (clickable, tooltip)
+ *   - suspended=true                 → Stop icon (cancel)
+ *
+ * Hosts wire `onPause` (suspend / resume) and `onCancel` (stop stream)
+ * to the gateway. The component picks which one to call based on state.
+ */
+export interface StreamStatisticsPauseControl {
+    turnOpen: boolean;
+    suspended: boolean;
+    suspending?: boolean;
+    onPause: () => void;
+    onCancel: () => void;
+}
+export interface StreamStatisticsProps {
+    /**
+     * Compact v2 chrome — mono font everywhere, hides elapsed time,
+     * renders a circle badge for session-size usage instead of a
+     * progress bar. Defaults to `false` (legacy v1 chrome).
+     */
+    compact?: boolean;
+    /** Optional inline Pause/Stop button. */
+    pauseControl?: StreamStatisticsPauseControl;
+}
+export declare const StreamStatistics: React.FC<StreamStatisticsProps>;
+export default StreamStatistics;

package/dist/src/components/AiChat/ChatPane/SubAgentBox.d.ts

@@ -0,0 +1,9 @@
+import { default as React } from 'react';
+import { SubAgentState } from '../stateConfiguration';
+export interface SubAgentBoxProps {
+    subAgent: SubAgentState;
+    compact?: boolean;
+    onLinkClicked: (link: string, content: string | null) => void;
+}
+declare const SubAgentBox: React.FC<SubAgentBoxProps>;
+export default SubAgentBox;

package/dist/src/components/AiChat/ChatPane/TaskList.d.ts

@@ -0,0 +1,6 @@
+import { default as React } from 'react';
+interface TaskListProps {
+    forceExpanded?: number;
+}
+export declare const TaskList: React.FC<TaskListProps>;
+export {};

package/dist/src/components/AiChat/ChatPane/friendlyToolConfig.d.ts

@@ -0,0 +1,11 @@
+export interface FriendlyToolEntry {
+    partial: string;
+    call: string;
+    response: string;
+    responseError?: string;
+    extractDetail?: (args: any) => string;
+}
+export declare const friendlyToolConfigRegistry: Record<string, FriendlyToolEntry>;
+export declare function configureFriendlyMapping(toolName: string, mapping: FriendlyToolEntry): void;
+export type FriendlyState = 'partial' | 'call' | 'response';
+export declare function getFriendlyLabel(toolName: string, state: FriendlyState, args?: any, isError?: boolean): string;

package/dist/src/components/AiChat/ChatPane/parts/AskUserPart.d.ts

@@ -0,0 +1,8 @@
+import { default as React } from 'react';
+import { PartRendererProps } from './types';
+type AskUserPartProps = Partial<PartRendererProps> & {
+    part: PartRendererProps['part'];
+    embedded?: boolean;
+};
+declare const AskUserPart: React.FC<AskUserPartProps>;
+export default AskUserPart;

package/dist/src/components/AiChat/ChatPane/parts/BoxedPart.d.ts

@@ -0,0 +1,4 @@
+import { default as React } from 'react';
+import { PartRendererProps } from './types';
+declare const BoxedPart: React.FC<PartRendererProps>;
+export default BoxedPart;

package/dist/src/components/AiChat/ChatPane/parts/FunctionPart.d.ts

@@ -0,0 +1,4 @@
+import { default as React } from 'react';
+import { PartRendererProps } from './types';
+declare const FunctionPart: React.FC<PartRendererProps>;
+export default FunctionPart;

package/dist/src/components/AiChat/ChatPane/parts/SuspendedPart.d.ts

@@ -0,0 +1,4 @@
+import { default as React } from 'react';
+import { PartRendererProps } from './types';
+declare const SuspendedPart: React.FC<PartRendererProps>;
+export default SuspendedPart;

package/dist/src/components/AiChat/ChatPane/parts/TextPart.d.ts

@@ -0,0 +1,4 @@
+import { default as React } from 'react';
+import { PartRendererProps } from './types';
+declare const TextPart: React.FC<PartRendererProps>;
+export default TextPart;

package/dist/src/components/AiChat/ChatPane/parts/ThoughtPart.d.ts

@@ -0,0 +1,4 @@
+import { default as React } from 'react';
+import { PartRendererProps } from './types';
+declare const ThoughtPart: React.FC<PartRendererProps>;
+export default ThoughtPart;

package/dist/src/components/AiChat/ChatPane/parts/UiToolDispatcher.d.ts

@@ -0,0 +1,16 @@
+import { default as React } from 'react';
+import { PartRendererProps } from './types';
+/**
+ * The built-in `uiTool` renderer. The library routes every UI render tool here
+ * (server flags them `functionDetails.isUi`); this dispatcher then looks up the
+ * host's `uiTools` registry by tool name and either renders the matched
+ * component or fires the matched action. Unregistered tools (or no registry at
+ * all) fall through to `FunctionPart`, preserving the pre-registry behaviour of
+ * showing them like a normal tool call.
+ *
+ * Hosts may still fully override the `uiTool` kind via `partRenderers={{ uiTool }}`
+ * — `MessagePart` prefers an explicit override over this default — but the
+ * registry is the intended extension point.
+ */
+declare const UiToolDispatcher: React.FC<PartRendererProps>;
+export default UiToolDispatcher;

package/dist/src/components/AiChat/ChatPane/parts/WaitingPart.d.ts

@@ -0,0 +1,4 @@
+import { default as React } from 'react';
+import { PartRendererProps } from './types';
+declare const WaitingPart: React.FC<PartRendererProps>;
+export default WaitingPart;

package/dist/src/components/AiChat/ChatPane/parts/index.d.ts

@@ -0,0 +1,20 @@
+import { InteractionPart } from '../../../../models/InteractionPart';
+import { PartKind, PartRenderer } from './types';
+import { default as TextPart } from './TextPart';
+import { default as ThoughtPart } from './ThoughtPart';
+import { default as FunctionPart } from './FunctionPart';
+import { default as WaitingPart } from './WaitingPart';
+import { default as SuspendedPart } from './SuspendedPart';
+import { default as BoxedPart } from './BoxedPart';
+export declare const DEFAULT_PART_RENDERERS: Record<PartKind, PartRenderer>;
+/**
+ * Maps an `InteractionPart` to the kind of renderer that should handle it.
+ * Returns `null` for parts that should not render anything (ServerError,
+ * unknown/filtered event types like ToolEvent which is dropped upstream
+ * in MessageAgent).
+ */
+export declare function classifyPart(part: InteractionPart): PartKind | null;
+export * from './types';
+export * from './uiToolRegistry';
+export { TextPart, ThoughtPart, FunctionPart, WaitingPart, SuspendedPart, BoxedPart };
+export { default as UiToolDispatcher } from './UiToolDispatcher';

package/dist/src/components/AiChat/ChatPane/parts/index.test.d.ts

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

package/dist/src/components/AiChat/ChatPane/parts/types.d.ts

@@ -0,0 +1,22 @@
+import { default as React } from 'react';
+import { InteractionPart } from '../../../../models/InteractionPart';
+import { Interaction } from '../../../../models/Interaction';
+export type PartKind = 'text' | 'thought' | 'function' | 'waiting' | 'suspended' | 'boxed' | 'uiTool' | 'askUser';
+export interface PartRendererProps {
+    part: InteractionPart;
+    message: Interaction;
+    onGoing: boolean;
+    preview: boolean;
+    isLastInlineInGroup?: boolean;
+    friendlyMode?: boolean;
+    onLinkClicked: (link: string, content: string | null) => void;
+}
+export type PartRenderer = React.ComponentType<PartRendererProps>;
+export type PartRendererMap = Partial<Record<PartKind, PartRenderer>>;
+/**
+ * Match the ask_user tool by function name across connectors. The programmed
+ * path emits the bare `ask_user`; live LLM connectors qualify it as
+ * `{Plugin}-ask_user` / `{Plugin}_ask_user` (with an empty pluginName), so a
+ * literal `=== 'ask_user'` misses real-model calls.
+ */
+export declare const isAskUser: (name?: string | null) => boolean;

package/dist/src/components/AiChat/ChatPane/parts/uiToolRegistry.d.ts

@@ -0,0 +1,121 @@
+import { default as React } from 'react';
+import { InteractionPart } from '../../../../models/InteractionPart';
+import { Interaction } from '../../../../models/Interaction';
+/**
+ * UI-tool registry — the host maps a tool NAME to either a React renderer or a
+ * fire-once side-effect ("action"), and the library owns everything else:
+ * routing the `uiTool` part kind here, parsing/unwrapping the wire args,
+ * normalizing the connector-qualified function name, firing actions once per
+ * tool-call id (and not on replay), and drawing an optional status chip.
+ *
+ * The per-entry generic (`render<TArgs>` / `action<TArgs>`) is a COMPILE-TIME
+ * assertion only: args arrive off the wire as `unknown` (usually a JSON string,
+ * sometimes double-encoded), so a missing field is `undefined` at runtime no
+ * matter what the type claims. Pass `opts.parse` when you want a real runtime
+ * guard/coercion.
+ *
+ * Build once at module load and pass the result as `<AiChatProvider uiTools={…} />`:
+ *
+ *     export const uiTools = createUiToolRegistry()
+ *       .render<{ id: string; subAgentId?: string }>('present_dashboard',
+ *           (a) => <ScriptDashboardViewer dashboardId={a.id} … />)
+ *       .action<{ mode?: 'create' | 'update' }>('present_dashboard_pad',
+ *           (a, { env }) => env.updateDashboardPad?.(JSON.parse(a.definitionJson)),
+ *           { status: 'Rascunho atualizado' })
+ *       .build();
+ */
+/** Default args shape when a registration omits its generic. */
+export type UiToolArgs = Record<string, unknown>;
+/** Context handed to every renderer. */
+export interface UiToolContext {
+    /** Normalized tool name (`UI_` marker + `{Plugin}-`/`{Plugin}_` qualifier stripped). */
+    name: string;
+    /** This tool call's id — stable across the call's Composing→Executing→Done lifecycle. */
+    callId: string;
+    /** The tool RESULT, if any. May be an object or a (possibly double-encoded) JSON string. */
+    response: unknown;
+    /**
+     * The tool's CLIENT-ONLY output — the payload it wrote to its SDK `ToolClientOutput` sink,
+     * already parsed. This is the preferred render source: it arrives correlated to THIS call (by
+     * id) on the result event (so multiple UI calls never race), the LLM never saw it, and it
+     * survives reload. `undefined` until the call has responded, or when the tool didn't opt in
+     * (fall back to `args`). Replaces the old slot-id-correlated tool-event lookup over `parts`.
+     */
+    clientOutput: unknown;
+    /** Sibling parts of the same interaction (e.g. present_tsx's compiled-JS event rides here). */
+    parts: ReadonlyArray<InteractionPart>;
+    /** The whole interaction this part belongs to. */
+    message: Interaction;
+    /** True while the turn is still streaming. */
+    onGoing: boolean;
+    /** True during historical replay / preview — actions must NOT re-fire side effects. */
+    preview: boolean;
+}
+/** Context handed to actions — adds the host environment. */
+export interface UiToolActionContext extends UiToolContext {
+    /**
+     * The host environment from `EnvironmentProvider` (e.g. `refreshDashboard`,
+     * `createDashboardPad`). Empty `{}` when no provider is in scope or during
+     * replay (`InertEnvironmentProvider` no-ops every callable) — so action calls
+     * simply dead-end rather than throw.
+     */
+    env: Record<string, unknown>;
+}
+export type UiToolRenderFn<TArgs> = (args: TArgs, ctx: UiToolContext) => React.ReactNode;
+export type UiToolActionFn<TArgs> = (args: TArgs, ctx: UiToolActionContext) => void | Promise<void>;
+export interface UiToolRenderOptions<TArgs> {
+    /** Runtime arg guard/coercion. Return `null` to render nothing (treated as invalid args). */
+    parse?: (raw: unknown) => TArgs | null;
+}
+export interface UiToolActionOptions<TArgs> {
+    /** Runtime arg guard/coercion. Return `null` to skip firing (treated as invalid args). */
+    parse?: (raw: unknown) => TArgs | null;
+    /**
+     * Optional status chip shown AFTER the action fires: a string, or a function
+     * of (args, ctx) returning the label (or `null` for no chip). Omit entirely
+     * for a silent action — no UI at all, just the side effect.
+     */
+    status?: string | ((args: TArgs, ctx: UiToolActionContext) => string | null);
+}
+export interface UiToolRenderEntry {
+    kind: 'render';
+    name: string;
+    render: UiToolRenderFn<any>;
+    parse?: (raw: unknown) => any;
+}
+export interface UiToolActionEntry {
+    kind: 'action';
+    name: string;
+    run: UiToolActionFn<any>;
+    parse?: (raw: unknown) => any;
+    status?: string | ((args: any, ctx: UiToolActionContext) => string | null);
+}
+export type UiToolEntry = UiToolRenderEntry | UiToolActionEntry;
+/** A built, read-only registry passed to `<AiChatProvider uiTools={…} />`. */
+export interface UiToolRegistry {
+    /** Resolve the entry for a RAW (possibly `UI_`-prefixed / connector-qualified) tool name. */
+    resolve(rawName: string | undefined | null): UiToolEntry | undefined;
+    /** All registered (normalized) names. */
+    names(): string[];
+}
+export interface UiToolRegistryBuilder {
+    render<TArgs = UiToolArgs>(name: string, render: UiToolRenderFn<TArgs>, opts?: UiToolRenderOptions<TArgs>): UiToolRegistryBuilder;
+    action<TArgs = UiToolArgs>(name: string, run: UiToolActionFn<TArgs>, opts?: UiToolActionOptions<TArgs>): UiToolRegistryBuilder;
+    build(): UiToolRegistry;
+}
+/**
+ * Tolerant unwrap for a tool's `clientOutput` payload. It reaches the client as a JSON string
+ * (server-serialized) on the live path and as a string off the persisted sibling on replay; peel up
+ * to three string layers (only when the trimmed text looks like JSON). Unlike {@link parseUiArgs}
+ * this does NOT require an object — a tool may hand the client an array or primitive. Returns the
+ * parsed value, the original non-string value as-is, or `undefined` when absent/unparseable.
+ */
+export declare function parseClientOutput(raw: unknown): unknown;
+/**
+ * Tolerant arg unwrap. Args reach the client as an object on the live path, but as a
+ * JSON string — occasionally double-encoded — on the persisted/replay path. Peel up to
+ * three string layers (only when the trimmed text looks like JSON), then require an
+ * object. Returns `null` when absent/unparseable; mirrors `InteractionPartUtils.uiSlotId`.
+ */
+export declare function parseUiArgs(raw: unknown): UiToolArgs | null;
+export declare function createUiToolRegistry(): UiToolRegistryBuilder;

package/dist/src/components/AiChat/index.d.ts

@@ -0,0 +1,13 @@
+export { default as AiChat } from './AiChat';
+export { default as ChatPane } from './ChatPane/ChatPane';
+export { AiChatProvider } from './AiChatProvider';
+export { AiChatDrawer } from './AiChatDrawer';
+export { AiChatFloating } from './AiChatFloating';
+export type { AiChatProps, AiChatHandle, AiChatStyleProps, AiChatDrawerProps, AiChatFloatingProps, SendMessageOptions, SendMessageUi, UserMessageRendererProps } from './AiChatTypes';
+export { useAiChatServices, useAiChatSessionStore } from './AiChatContext';
+export { createAiChatSessionStore } from './AiChatSessionStore';
+export type { SubAgentState } from './stateConfiguration';
+export type { SubAgentBoxProps } from './ChatPane/SubAgentBox';
+export { default as SubAgentBox } from './ChatPane/SubAgentBox';
+export type { FriendlyToolEntry } from './ChatPane/friendlyToolConfig';
+export { configureFriendlyMapping } from './ChatPane/friendlyToolConfig';

package/dist/src/components/AiChat/sessionStateManagerService.d.ts

@@ -0,0 +1,47 @@
+import { AiChatState, AiChatStore } from './stateConfiguration';
+import { ChatSession } from '../../models/ChatSession';
+import { SendMessageResponse } from '../../models/SendMessageResponse';
+import { AgentContext } from '../../models/contexts';
+import { IArtifactService } from '../../services/interfaces/artifactService';
+import { AgentGatewayService } from '../../services/servers/AgentGatewayService';
+import { ISessionService } from '../../services/servers/sessionService/ISessionService';
+export declare const WARNING_THRESHOLD = 0.75;
+export declare const BASE_MULTIPLIER = 1000;
+export declare const IDLE_TIMEOUT: number;
+export declare const DEFAULT_WAIT_TIME = 500;
+export declare const MAX_RETRY_WAIT = 20000;
+export interface SessionStateManagerOptions {
+    onSessionEstablished?: (sessionId: string) => void;
+}
+export declare class SessionStateManagerService {
+    private idleTime;
+    internalHearBeat: ReturnType<typeof setInterval> | null;
+    lastConCheck: number;
+    sessionState: AiChatState;
+    agentGatewayService: AgentGatewayService;
+    paused: boolean;
+    waitTimeForRetry: number;
+    sessionService: ISessionService;
+    workingContext?: AgentContext;
+    artifactService: IArtifactService;
+    workingSessionId?: string;
+    pendingClosePromise?: Promise<SendMessageResponse | null>;
+    private onSessionEstablished?;
+    constructor(agentGatewayService: AgentGatewayService, sessionService: ISessionService, artifactService: IArtifactService, sessionStore: AiChatStore, options?: SessionStateManagerOptions);
+    /**
+     * Update the agent context the manager will use on subsequent reconnects.
+     * Called by AiChatProvider when its `agentContext` prop changes — without
+     * this, the heartbeat-driven `processRetryLoop` would re-open with the
+     * stale context captured at the initial bind.
+     */
+    setAgentContext(context: AgentContext): void;
+    pause(): void;
+    start(): void;
+    beat(): void;
+    createSession(context: AgentContext, sessionId: string): Promise<ChatSession>;
+    retrieveSession(_context: AgentContext, sessionId: string): Promise<ChatSession | null>;
+    bindAndOpenLiveSession(context: AgentContext, sessionId?: string): Promise<void>;
+    closeLiveConnection(stoneCold?: boolean, closeTurn?: boolean): Promise<void>;
+    stop(): Promise<void>;
+    processRetryLoop(_identification?: string): void;
+}

package/dist/src/components/AiChat/stateConfiguration.d.ts

@@ -0,0 +1,80 @@
+import { ChatSession } from '../../models/ChatSession';
+import { Interaction } from '../../models/Interaction';
+import { ConnectionState } from '../../models/connectionState';
+import { StoreApi } from 'zustand';
+import { SkillLevel } from '../../models/enums';
+import { ToolEventDetails } from '../../models/ServerEvent';
+import { InteractionStatistics } from '../../models/semanticKernelModel/models';
+import { ISessionService } from '../../services/servers/sessionService/ISessionService';
+export type AiChatStore = StoreApi<AiChatState>;
+export declare function createAiChatStore(sessionService: ISessionService, onRenderPrompt?: (prompt: string) => {
+    promptAsString?: string;
+    json?: string;
+}): AiChatStore;
+export interface SubAgentState {
+    id: string;
+    name?: string;
+    interaction: Interaction;
+    completed: boolean;
+}
+/**
+ * Per-turn suspend state shared by every UI surface that exposes a
+ * pause/continue/stop control (PromptV2's send-button cluster,
+ * RunProgressPanelV2's header). v1 kept this state inside the Prompt
+ * component because that was the only place it surfaced; v2 ships
+ * the same control in two places, so a local state slice would let
+ * them disagree (pause in one surface didn't flip the icon in the
+ * other). The state machine is:
+ *
+ *   idle ──pause()──> suspending ──ack──> suspended
+ *                                            │
+ *                                            ├── stop()       ──> idle (turn killed)
+ *                                            ├── continue()   ──> idle (partial finalized)
+ *                                            └── sendMessage  ──> idle (auto-cleared by gateway)
+ *
+ * Reset to `idle` whenever the turn closes so the cluster doesn't get
+ * stuck on "Continuar" between turns.
+ */
+export type SuspendState = 'idle' | 'suspending' | 'suspended';
+export interface AiChatState {
+    session: ChatSession | null;
+    sendingMessage: boolean;
+    loading: boolean;
+    loadingError?: string | null;
+    sessionActive: boolean;
+    loadingType: null | 'NEW' | 'EXISTING';
+    skillLevel: SkillLevel;
+    turnOpen: boolean;
+    suspendState: SuspendState;
+    statistics?: InteractionStatistics;
+    connectionStatus: ConnectionState;
+    lastToolEvent?: ToolEventDetails;
+    lastActivity: number;
+    messages: Interaction[];
+    currentMessage: Interaction | null;
+    _turnCompleteCounter: number;
+    subAgents: Map<string, SubAgentState>;
+    setStatistics: (stats: InteractionStatistics) => void;
+    setIsSessionActive: (active: boolean) => void;
+    setLastActivity: () => void;
+    setLoadingInformation: (state: ConnectionState, loading: boolean, loadingType: 'EXISTING' | 'NEW' | undefined, loadingError?: string) => void;
+    setSendingMessage: (newValue: boolean) => void;
+    setLoadedInstructions: (instructions: string[]) => void;
+    setCurrentMessage: (message: Interaction | null) => void;
+    setLastToolEvent: (ToolEventDetails: ToolEventDetails | null) => void;
+    resetMessages: () => void;
+    setNewMessage: (message: Interaction) => void;
+    setTurnOpen: (status: boolean) => void;
+    setSuspendState: (status: SuspendState) => void;
+    setConnectionStatus: (status: ConnectionState) => void;
+    setSubAgentMessage: (subAgentId: string, interaction: Interaction, name?: string) => void;
+    completeSubAgent: (subAgentId: string) => void;
+    removeSubAgent: (subAgentId: string) => void;
+    bindingPromise: Promise<ChatSession | null> | null;
+    setPartialSession: (session: Partial<ChatSession | null>) => void;
+    setSession: (session: ChatSession | null) => void;
+    onRenderPrompt?: (prompt: string) => {
+        promptAsString?: string;
+        json?: any;
+    };
+}

package/dist/src/components/Library/ArtifactRender.d.ts

@@ -0,0 +1,18 @@
+import { JSX } from 'react';
+import { Artifact } from '../../models/Artifact';
+import { IArtifactService } from '../../services/interfaces/artifactService';
+interface ArtifactRenderProps {
+    artifact?: Artifact | null;
+    mode: 'full' | 'compact';
+    isMobile: boolean;
+    isTablet: boolean;
+    preview: boolean;
+    sessionId?: string;
+    renderMode?: 'browser' | 'serverside';
+    naked: boolean;
+    fullImage?: boolean;
+    artifactService: IArtifactService;
+    onExpand?: (artifact: Artifact) => void;
+}
+declare const ArtifactRender: ({ artifact, mode, sessionId, preview, onExpand, renderMode, naked, fullImage }: ArtifactRenderProps) => JSX.Element;
+export default ArtifactRender;

package/dist/src/components/Library/DelayTextComponent.d.ts

@@ -0,0 +1,9 @@
+import { default as React } from 'react';
+interface DelayTextComponentProps {
+    text: string;
+    totalTime: number;
+    initialDelay: number;
+    useMarkdown?: boolean;
+}
+export declare const DelayTextComponent: React.FC<DelayTextComponentProps>;
+export default DelayTextComponent;

package/dist/src/components/Library/LinearBackgroundProgress.d.ts

@@ -0,0 +1,8 @@
+export interface LinerBackgroundProgressProps {
+    value: number;
+    completedColor: string;
+    unCompletedColor: string;
+    children: React.ReactNode;
+}
+declare function LinerBackgroundProgress({ value, children, completedColor, unCompletedColor }: LinerBackgroundProgressProps): import("react/jsx-runtime").JSX.Element;
+export default LinerBackgroundProgress;