@m6d/cortex-angular 0.14.0 → 0.14.1

package/types/m6d-cortex-angular.d.ts

@@ -2,14 +2,20 @@
 
 import * as i0 from '@angular/core';
 import { Injector, OnInit, Signal, TemplateRef, Type } from '@angular/core';
-import { ToolCallPart, UIMessage } from '@tanstack/ai';
-import { Observable } from 'rxjs';
+import { MessagePart, ToolCallPart, UIMessage } from '@tanstack/ai';
 
 declare const LOCALES: readonly [
 	"en",
 	"ar"
 ];
 export type Locale = (typeof LOCALES)[number];
+declare const MESSAGE_ROLES: readonly [
+	"system",
+	"user",
+	"assistant",
+	"trigger"
+];
+export type MessageRole = (typeof MESSAGE_ROLES)[number];
 declare const ATTACHMENT_STATUSES: readonly [
 	"pending",
 	"described",
@@ -55,6 +61,20 @@ export type ThreadSummary = {
 export type CreateThreadRequest = {
 	variables?: Record<string, string | number | boolean>;
 };
+export type TokenUsage = {
+	input: {
+		noCache: number;
+		cacheRead: number;
+		cacheWrite: number;
+		total: number;
+	};
+	output: {
+		reasoning: number;
+		text: number;
+		total: number;
+	};
+	total: number;
+};
 /**
  * What Cortex offers this agent's clients, fetched once at widget startup.
  * The widget hides UI for anything absent; Cortex enforces each.
@@ -79,6 +99,17 @@ export type AgentCapabilities = {
 	 */
 	debug: boolean;
 };
+export type MessageMetadata = {
+	/** ISO time Cortex stored the message; stamped from the row when a transcript is served. */
+	createdAt?: string;
+	modelId?: string;
+	providerMetadata?: unknown;
+	isAborted?: boolean;
+	tokenUsage?: TokenUsage;
+	attachments?: AttachmentSummary[];
+	/** Set on `trigger` messages: the firing that wrote them. */
+	trigger?: TriggerFiringSummary;
+};
 /**
  * One landing-page chip: the widget shows `title` and sends `prompt` as the
  * first message when clicked. The two may be the same text.
@@ -90,6 +121,52 @@ export type Suggestion = {
 /** The manifest's suggestion and greeting schemas are built from these. */
 export type Suggestions = Record<Locale, Suggestion[]>;
 export type Greeting = Record<Locale, string>;
+export type TriggerFiringSummary = {
+	name: string;
+	firingId: string;
+	firedAt: string;
+	payload: unknown;
+};
+/**
+ * A stored message as it is persisted and served: the SDK's parts plus the
+ * envelope Cortex derives for the UIs, carried in the SDK message's own
+ * `metadata` bag so it travels with the message over the stream and the
+ * transcript alike.
+ *
+ * `TPart` stays generic so this file keeps its zero dependencies — both
+ * sides substitute the SDK's `MessagePart`.
+ */
+export type CortexMessage<TPart = unknown> = {
+	id: string;
+	/** `trigger` rows carry a firing's instructions; the UIs render them as an event, not a bubble. */
+	role: MessageRole;
+	parts: TPart[];
+	metadata?: MessageMetadata;
+};
+declare const TRIGGER_DROP_REASONS: readonly [
+	"busy",
+	"approval_pending",
+	"budget",
+	"rate_limited"
+];
+export type TriggerDropReason = (typeof TRIGGER_DROP_REASONS)[number];
+/**
+ * Body of a `POST /chat` the thread did not take: 409 while a run holds the
+ * thread or a call on it waits for a decision, or when the answers it
+ * carried fit no open call, were already applied, or answer a call whose
+ * origin is out of reach (`no_turn`); 429 once the agent's request bucket is
+ * spent, with `Retry-After`.
+ */
+export type ChatDropped = {
+	outcome: "dropped";
+	reason: Exclude<TriggerDropReason, "budget"> | "no_turn";
+};
+/**
+ * The drop a widget tells its user about by name: a call on the thread waits
+ * for approval, so the message goes back to the composer. Any other drop
+ * shows as a failed turn.
+ */
+export type SendRefusal = Extract<ChatDropped["reason"], "approval_pending">;
 export type CortexHeaders = Record<string, string>;
 /**
  * How the widget reaches Cortex. `baseUrl` may be a thunk so a consumer with
@@ -262,8 +339,11 @@ export type CortexSlotContexts<View> = {
 	landing: LandingContext<View>;
 	threadList: CortexThreadListContext;
 };
-/** Why Cortex dropped a message instead of running it: a call on the thread waits for approval. */
-export type SendRefusal = "approval_pending";
+/**
+ * Why Cortex left a read unanswered: it could not be reached (or failed),
+ * it refused the caller's sign-in (401), or it serves no such agent (404).
+ */
+export type Unanswered = "unreachable" | "refused" | "missing";
 /** Why the composer refused a file before uploading it: the attachment policy's reason, or one file too many. */
 export type AttachmentRefusal = Exclude<ReturnType<typeof checkAttachmentPolicy>, "ok"> | "count";
 export type QueuedAttachment = {
@@ -276,21 +356,86 @@ export type QueuedAttachment = {
 	attachmentId?: string;
 	summary?: AttachmentSummary;
 };
-/**
- * Why Cortex left a read unanswered: it could not be reached (or failed),
- * it refused the caller's sign-in (401), or it serves no such agent (404).
- */
-export type Unanswered = "unreachable" | "refused" | "missing";
 /**
  * A turn shown as failed, with Cortex's reason when it gave one (a message
  * that never got out has none). The reason may name the model provider's
- * answer, so a widget shows it only where its debug view is offered. A
- * message Cortex refused names why instead.
+ * answer, so the widget's state keeps it only where Cortex sends the debug
+ * view. A message Cortex refused names why instead.
  */
 export type TurnFailure = {
 	reason: string | undefined;
 	refusal?: SendRefusal;
 };
+/** The open conversation, as a widget draws it. */
+export type ChatSessionState = {
+	/** Each carries Cortex's envelope (usage, model id, attachments, time) in its `metadata`. */
+	messages: UIMessage[];
+	isAgentWorking: boolean;
+	isLoadingMessages: boolean;
+	/**
+	 * A call is owed an answer. Only while no stream is open: mid-turn an open
+	 * call is a tool Cortex is running. Read off the transcript, so the composer
+	 * comes back the moment an answer settles its call, long before the
+	 * continuation it sends ends.
+	 */
+	hasPendingToolCalls: boolean;
+	/** A call waits for the user to approve or deny it: no message may go out until it is decided. */
+	awaitsApproval: boolean;
+	/** The last turn failed: Cortex said its run failed, or the message never got out. */
+	turnFailure: TurnFailure | undefined;
+};
+/** Everything a widget draws, the same for every framework. */
+export type CortexWidgetState = {
+	/** Newest first; undefined until the first list read lands or Cortex refuses it. */
+	threads: ThreadSummary[] | undefined;
+	/** The open thread, as the list has it now; undefined on a blank chat. */
+	selected: ThreadSummary | undefined;
+	/**
+	 * The open thread's conversation; blank while none is open. A failed
+	 * turn's reason may name the model provider's answer, so it is here only
+	 * where Cortex sends this caller the debug view.
+	 */
+	session: ChatSessionState;
+	/** What Cortex offers this agent's clients; undefined until the handshake answers. */
+	capabilities: AgentCapabilities | undefined;
+	/** Why the handshake has not answered yet, once a try has failed. */
+	unanswered: Unanswered | undefined;
+	/** The files held for the next message. */
+	attachments: QueuedAttachment[];
+	/** A thread is being created for the message on its way out; the composer waits for it. */
+	creating: boolean;
+	screen: "chat" | "threads";
+	/** Full mode's history sidebar, slid in on a narrow viewport. */
+	sidebarOpen: boolean;
+	/** The reader's debug toggle; on only while the handshake offers the debug view. */
+	debugMode: boolean;
+	/**
+	 * What the header, landing and history are drawn from: one object until
+	 * one of its fields changes, which a streamed chunk does only as the turn
+	 * starts and stops working, so a framework redraws them only then.
+	 */
+	parts: Pick<CortexWidgetState, "threads" | "selected" | "capabilities" | "debugMode"> & {
+		isWorking: boolean;
+	};
+};
+export type CortexAngularConfig = CortexConfig & {
+	toolComponents?: Record<string, Type<CortexToolComponentInputs>>;
+	injector?: Injector;
+};
+/** The landing's context, its composer a template to place with `ngTemplateOutlet`. */
+export type CortexLandingContext = LandingContext<TemplateRef<unknown>>;
+/** Each part of the widget a consumer can draw itself, with the context it receives. */
+export type CortexAngularSlotContexts = CortexSlotContexts<TemplateRef<unknown>>;
+declare const LOCALES$1: readonly [
+	"en",
+	"ar"
+];
+type Locale$1 = (typeof LOCALES$1)[number];
+declare const TOOL_SURFACES: readonly [
+	"inline",
+	"modal"
+];
+export type ToolSurface = (typeof TOOL_SURFACES)[number];
 declare const ATTACHMENT_STATUSES$1: readonly [
 	"pending",
 	"described",
@@ -312,234 +457,211 @@ export type AttachmentSummary$1 = {
 	origin: AttachmentOrigin$1;
 	description: string | null;
 };
-export type CortexAngularConfig = CortexConfig & {
-	toolComponents?: Record<string, Type<CortexToolComponentInputs>>;
-	injector?: Injector;
+/**
+ * Response of `POST /chat/:threadId/abort`. `aborted: false` means there was no
+ * live run to abort — the turn had already committed — so the caller must not
+ * present the turn as aborted and should read the settled state back instead.
+ */
+export type AbortRunResult$1 = {
+	aborted: boolean;
 };
-/** The landing's context, its composer a template to place with `ngTemplateOutlet`. */
-export type CortexLandingContext = LandingContext<TemplateRef<unknown>>;
-/** Each part of the widget a consumer can draw itself, with the context it receives. */
-export type CortexAngularSlotContexts = CortexSlotContexts<TemplateRef<unknown>>;
-declare class AttachmentQueueService {
-	readonly items: import("@angular/core").WritableSignal<QueuedAttachment[]>;
-	private readonly flags;
-	readonly uploading: import("@angular/core").Signal<boolean>;
-	readonly busy: import("@angular/core").Signal<boolean>;
-	readonly hasReady: import("@angular/core").Signal<boolean>;
-	private readonly chatService;
-	readonly store: {
-		getState: () => QueuedAttachment[];
-		subscribe: (listener: () => void) => () => void;
-		accept: (files: File[]) => void;
-		remove: (localId: string) => void;
-		clear: (threadId: string | undefined) => void;
-		consumeReady: () => {
-			status: "ready";
-			summary: AttachmentSummary$1;
-			localId: string;
-			filename: string;
-			refusal?: "type" | "size" | "name" | "count";
-			threadId?: string;
-			attachmentId?: string;
-		}[];
-		restoreConsumed: (threadId: string | undefined) => void;
-		discardConsumed: () => void;
+type TokenUsage$1 = {
+	input: {
+		noCache: number;
+		cacheRead: number;
+		cacheWrite: number;
+		total: number;
 	};
-	constructor();
-	static ɵfac: i0.ɵɵFactoryDeclaration<AttachmentQueueService, never>;
-	static ɵprov: i0.ɵɵInjectableDeclaration<any>;
-}
-declare class CortexChatService {
+	output: {
+		reasoning: number;
+		text: number;
+		total: number;
+	};
+	total: number;
+};
+/**
+ * What Cortex offers this agent's clients, fetched once at widget startup.
+ * The widget hides UI for anything absent; Cortex enforces each.
+ */
+export type AgentCapabilities$1 = {
+	attachments: boolean;
 	/**
-	 * Selection is the Thread handed to `selectThread`, resolved against the live
-	 * list: the row there receives the title and isRunning updates Cortex
-	 * pushes, so the selection follows them without hand-syncing. The snapshot
-	 * only answers for a thread the list has not caught up with yet.
+	 * False when this caller may not send to the chat: the agent's `message`
+	 * trigger is off, or the caller only reads (`readOnly`). The widget hides
+	 * its composer and answers no tool call.
 	 */
-	readonly selectedThread: import("@angular/core").Signal<ThreadSummary | undefined>;
-	private readonly chat;
-	/** The open conversation's transcript; empty while nothing is selected. */
-	readonly messages: import("@angular/core").Signal<import("@tanstack/ai-client").UIMessage<readonly import("@tanstack/ai").AnyClientTool[], any>[]>;
-	readonly isLoadingMessages: import("@angular/core").WritableSignal<boolean>;
-	readonly isAgentWorking: import("@angular/core").Signal<boolean>;
+	messages: boolean;
+	/** True when the caller only reads, as an operator inspecting a user's thread does. */
+	readOnly: boolean;
+	/** Prompt chips on the blank-chat landing per locale; clicking one sends its `prompt` as the first message. */
+	suggestions: Suggestions$1;
+	/** Headline of the blank-chat landing per locale; "" falls back to the widget's built-in copy. */
+	greeting: Greeting$1;
 	/**
-	 * Derived, never hand-synced: a call only counts as owed while the stream is
-	 * idle — mid-turn an unsettled call is just a tool Cortex is executing. Reading
-	 * straight from the SDK's signals is what brings the composer back the
-	 * instant `addToolResult` settles the call part — the SDK's delivery promise
-	 * only resolves once the continuation turn ends, far too late to gate UI on.
+	 * Whether this caller gets the debug view: tool inputs and outputs, reasoning,
+	 * model calls. Cortex sends anyone else only what the widget's normal UI draws.
 	 */
-	readonly hasPendingToolCalls: import("@angular/core").Signal<boolean>;
-	/** A call waits for the user to approve or deny it: no message may go out until it is decided. */
-	readonly awaitsApproval: import("@angular/core").Signal<boolean>;
-	/** The last turn failed: Cortex said its run failed, or the message never got out. */
-	readonly turnFailure: import("@angular/core").WritableSignal<TurnFailure | undefined>;
-	/** The text of a message Cortex refused, handed back to the composer until a message goes out. */
-	readonly returnedDraft: import("@angular/core").WritableSignal<string | undefined>;
-	/** What Cortex offers this agent's clients; undefined until the handshake answers. */
-	readonly capabilities: import("@angular/core").WritableSignal<AgentCapabilities | undefined>;
-	/** Why the handshake has not answered yet, once a try has failed. */
-	readonly unanswered: import("@angular/core").WritableSignal<Unanswered | undefined>;
-	private readonly events;
-	private readonly selectedThreadSnapshot;
-	private readonly config;
-	private readonly api;
-	private readonly threadService;
-	private readonly wsService;
-	private readonly destroyRef;
-	private readonly environmentInjector;
-	/** Owns the current thread's chat client; destroying it stops and disposes it. */
-	private chatInjector;
-	/** The turn in flight on the current chat client; replaced with it on every mount. */
-	private lifecycle;
-	private pendingThreadCreation;
-	private refreshing;
-	private stopCapabilities;
+	debug: boolean;
+};
+type Suggestion$1 = {
+	title: string;
+	prompt: string;
+};
+type Suggestions$1 = Record<Locale$1, Suggestion$1[]>;
+type Greeting$1 = Record<Locale$1, string>;
+/**
+ * Response of `POST /chat/:threadId/tools/:toolCallId/initiate` for a pending
+ * call stamped with an embed. The payload is for the widget only; it never
+ * reaches the LLM.
+ */
+export type ClientToolInitiateResult$1 = {
+	embedUrl: string;
+	surface: ToolSurface;
+	embedOrigin: string;
+};
+/**
+ * One model call of the turn that wrote a message, raw, in the order the
+ * turn ran them: `GET /threads/:threadId/messages/:messageId/llm-requests`
+ * answers a list, for the request inspector.
+ */
+export type LlmRequest$1 = {
+	id: string;
+	prompt: string;
+	output: string | null;
+	tokenUsage: TokenUsage$1 | null;
+};
+/** A message as Cortex serves it: SDK parts plus Cortex's metadata envelope. */
+export type CortexChatMessage = CortexMessage<MessagePart>;
+declare class CortexChatService {
+	readonly widget: {
+		api: {
+			getCapabilities(): Promise<AgentCapabilities$1>;
+			listThreads(): Promise<ThreadSummary[]>;
+			createThread(): Promise<ThreadSummary>;
+			deleteThread(threadId: string): Promise<void>;
+			listMessages(threadId: string): Promise<CortexChatMessage[]>;
+			listLlmRequests(threadId: string, messageId: string): Promise<LlmRequest$1[]>;
+			abortStream(threadId: string): Promise<AbortRunResult$1>;
+			initiateToolCall(threadId: string, toolCallId: string): Promise<ClientToolInitiateResult$1>;
+			uploadAttachment(threadId: string, file: File): Promise<AttachmentSummary$1>;
+			deleteAttachment(id: string): Promise<void>;
+			downloadAttachment(id: string): Promise<{
+				blob: Blob;
+				name: string;
+			}>;
+			resolveHeaders: () => Promise<{
+				[x: string]: string;
+			}>;
+			resolveUrl: (path: string) => string;
+		};
+		getState: () => CortexWidgetState;
+		getDraft: () => string;
+		subscribe: (listener: () => void) => () => void;
+		start: () => void;
+		stop: () => void;
+		setDraft: (text: string) => void;
+		submit: (text: string) => Promise<{
+			readonly sent: false;
+			readonly text: string;
+		} | {
+			readonly sent: true;
+		}>;
+		sendDraft: (launch: (text: string) => void) => void;
+		abort: () => Promise<void>;
+		addToolResult: (toolCallId: string, toolName: string, output: unknown) => Promise<void>;
+		respondToApproval: (call: import("@tanstack/ai").ToolCallPart, approved: boolean) => Promise<void>;
+		openThread: (thread: ThreadSummary) => void;
+		newChat: () => void;
+		deleteThread: (threadId: string) => Promise<void>;
+		attachFiles: (files: File[]) => void;
+		removeAttachment: (localId: string) => void;
+		openHistory: () => void;
+		closeHistory: () => void;
+		toggleDebug: () => void;
+	};
+	private readonly snapshot;
+	private readonly text;
+	readonly state: import("@angular/core").Signal<CortexWidgetState>;
+	readonly draft: import("@angular/core").Signal<string>;
+	readonly selectedThread: import("@angular/core").Signal<ThreadSummary | undefined>;
+	readonly messages: import("@angular/core").Signal<import("@tanstack/ai").UIMessage<unknown>[]>;
+	readonly isAgentWorking: import("@angular/core").Signal<boolean>;
+	readonly debugMode: import("@angular/core").Signal<boolean>;
+	readonly turnFailure: import("@angular/core").Signal<TurnFailure | undefined>;
+	/** What the header, landing and history are drawn from: a streamed chunk leaves it as it was. */
+	readonly parts: import("@angular/core").Signal<Pick<CortexWidgetState, "threads" | "capabilities" | "debugMode" | "selected"> & {
+		isWorking: boolean;
+	}>;
 	constructor();
-	/**
-	 * Kicked off by the widget once its `config` input is bound. This cannot happen in
-	 * the constructor: the widget builds its children during its creation pass, which
-	 * Angular runs before it binds inputs, so the transport is not knowable yet.
-	 */
-	start(): void;
-	/**
-	 * Capability-gated controls stay hidden until the handshake answers, so it
-	 * is asked until it does, and afresh after every reconnect: the old answer
-	 * may be stale (a trigger toggled while the socket was down), so it is
-	 * forgotten first. Why it has not answered is shown until an answer arrives.
-	 */
-	private loadCapabilities;
-	get events$(): Observable<"onError" | "onFinish" | "onThreadSelected" | "onSend">;
-	selectThread(thread: ThreadSummary, options?: {
-		skipLoadingMessages?: boolean;
-	}): Observable<ThreadSummary>;
-	deselectThread(): void;
-	/**
-	 * The id of the thread the next message belongs to, creating it when the widget is
-	 * still on a blank chat.
-	 */
-	ensureThread(): Observable<string>;
-	send(prompt: string, attachments?: AttachmentSummary[]): Observable<void>;
-	/** Answers a tool call on behalf of a tool component or the client tool
-	 * embed. Returns the delivery, which fails when the answer did not reach
-	 * Cortex, so the caller can ask for it again instead of stranding the call. */
-	addToolResult(toolCallId: string, toolName: string, output: unknown): Promise<void>;
-	/** The user's decision on a call the run parked on; the run resumes once delivered. */
-	respondToApproval(approvalId: string, approved: boolean): Promise<void>;
-	abort(): Promise<void>;
-	deleteThread(threadId: string): Observable<void>;
-	/**
-	 * Points the widget at a thread with a chat client of its own. Cortex owns
-	 * the transcript: on mount the client asks it for the transcript and for
-	 * whatever run is still generating, so selecting a thread, reloading the page
-	 * and a second tab all re-attach through one path.
-	 */
-	private mountChat;
-	/**
-	 * Re-mounts the current thread's chat so its hydration re-reads the transcript
-	 * and re-attaches to whatever run is live now. This is how a run another tab
-	 * started, and a websocket that dropped and came back, land in this widget.
-	 * A caller passes the thread when it holds fresher state than the list.
-	 */
-	private reattach;
-	private createConnection;
-	private refreshMessages;
-	private readBackMessages;
-	private subscribeToWsEvents;
-	/**
-	 * Only what these events mean for the open conversation — their list-shaped
-	 * side is CortexThreadService's, which absorbs them on its own subscription.
-	 */
-	private onWsEvent;
-	private subscribeToWsConnections;
 	static ɵfac: i0.ɵɵFactoryDeclaration<CortexChatService, never>;
 	static ɵprov: i0.ɵɵInjectableDeclaration<any>;
 }
 /** The chat widget: the thread list, the open conversation and its composer, for the agent `config` points at. */
 export declare class CortexChatWidgetComponent implements OnInit {
 	readonly config: import("@angular/core").InputSignal<CortexAngularConfig>;
-	protected readonly debugMode: import("@angular/core").WritableSignal<boolean>;
-	/**
-	 * Whether this caller may start and delete conversations: only once the
-	 * handshake says so, like every capability-gated control, and never for a
-	 * caller that only reads, as an operator inspecting a thread does.
-	 */
-	private readonly writes;
-	protected readonly screen: import("@angular/core").WritableSignal<"chat" | "threads">;
-	protected readonly sidebarOpen: import("@angular/core").WritableSignal<boolean>;
-	protected readonly viewMode: import("@angular/core").Signal<CortexViewMode>;
-	private readonly composer;
+	protected readonly direction: import("@angular/core").Signal<"ltr" | "rtl">;
 	private readonly landingComposer;
 	/** The consumer's own parts by slot; each replaces the widget's default and gets the same context. */
 	private readonly slotDirectives;
 	protected readonly slots: import("@angular/core").Signal<Map<keyof CortexAngularSlotContexts, TemplateRef<{
 		$implicit: CortexHeaderContext | CortexThreadListContext | LandingContext<TemplateRef<unknown>>;
 	}>>>;
-	/** Why the handshake has not answered, worded for the composer's place. */
-	protected readonly unansweredNotice: import("@angular/core").Signal<"translate_access_refused" | "translate_agent_unreachable" | "translate_agent_missing" | undefined>;
-	protected readonly chatHeader: import("@angular/core").Signal<{
-		openHistory: () => void;
-		closeHistory: () => void;
-		toggleDebug: () => void;
-		newChat?: (() => void) | undefined;
-		screen: "chat" | "threads";
-		viewMode: CortexViewMode;
-		title: string | null;
-		agentName: string | undefined;
-		threadCount: number | undefined;
-		isWorking: boolean;
-		debug: {
-			shown: boolean;
-			on: boolean;
+	protected chat: CortexChatService;
+	protected readonly parts: import("@angular/core").Signal<{
+		chatHeader: {
+			screen: "chat" | "threads";
+			viewMode: CortexViewMode;
+			title: string | null;
+			agentName: string | undefined;
+			threadCount: number | undefined;
+			isWorking: boolean;
+			debug: {
+				shown: boolean;
+				on: boolean;
+			};
+			newChat: (() => void) | undefined;
+			openHistory: () => void;
+			closeHistory: () => void;
+			toggleDebug: () => void;
 		};
-	}>;
-	protected readonly threadsHeader: import("@angular/core").Signal<{
-		openHistory: () => void;
-		closeHistory: () => void;
-		toggleDebug: () => void;
-		newChat?: (() => void) | undefined;
-		screen: "chat" | "threads";
-		viewMode: CortexViewMode;
-		title: string | null;
-		agentName: string | undefined;
-		threadCount: number | undefined;
-		isWorking: boolean;
-		debug: {
-			shown: boolean;
-			on: boolean;
+		threadsHeader: {
+			screen: "chat" | "threads";
+			viewMode: CortexViewMode;
+			title: string | null;
+			agentName: string | undefined;
+			threadCount: number | undefined;
+			isWorking: boolean;
+			debug: {
+				shown: boolean;
+				on: boolean;
+			};
+			newChat: (() => void) | undefined;
+			openHistory: () => void;
+			closeHistory: () => void;
+			toggleDebug: () => void;
+		};
+		landing: {
+			threads: ThreadSummary[] | undefined;
+			composer: TemplateRef<unknown>;
+			openThread: (thread: ThreadSummary) => void;
+			openHistory: () => void;
+			greeting: string;
+			suggestions: Suggestion[];
+			send: (prompt: string) => void;
+		};
+		threadList: {
+			newChat?: (() => void) | undefined;
+			deleteThread?: ((threadId: string) => undefined) | undefined;
+			threads: ThreadSummary[] | undefined;
+			selectedThreadId: string | undefined;
+			openThread: (thread: ThreadSummary) => void;
 		};
 	}>;
-	protected readonly landing: import("@angular/core").Signal<{
-		threads: ThreadSummary[] | undefined;
-		composer: TemplateRef<unknown>;
-		openThread: (thread: ThreadSummary) => void;
-		openHistory: () => void;
-		greeting: string;
-		suggestions: Suggestion[];
-		send: (prompt: string) => void;
-	}>;
-	protected readonly threadList: import("@angular/core").Signal<{
-		deleteThread?: ((threadId: string) => import("rxjs").Subscription) | undefined;
-		newChat?: (() => void) | undefined;
-		threads: ThreadSummary[] | undefined;
-		selectedThreadId: string | undefined;
-		openThread: (thread: ThreadSummary) => void;
-	}>;
-	protected chatService: CortexChatService;
-	protected queue: AttachmentQueueService;
-	private threadService;
+	protected readonly composerSlot: import("@angular/core").Signal<"translate_access_refused" | "translate_agent_unreachable" | "translate_agent_missing" | "composer" | "translate_read_only" | "translate_messages_disabled" | undefined>;
 	private readonly injector;
-	private readonly destroyRef;
 	ngOnInit(): void;
-	private headerContext;
-	protected closeSidebar(): void;
-	private toggleDebugMode;
-	private selectThread;
-	private openHistory;
-	private closeHistory;
 	protected onWidgetDragOver(event: DragEvent): void;
 	protected onWidgetDrop(event: DragEvent): void;
-	private newChat;
 	static ɵfac: i0.ɵɵFactoryDeclaration<CortexChatWidgetComponent, never>;
 	static ɵcmp: i0.ɵɵComponentDeclaration<CortexChatWidgetComponent, "cortex-chat-widget", never, {
 		"config": {