@m6d/cortex-angular 0.17.0 → 0.18.0

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

@@ -3,19 +3,76 @@
 import * as i0 from '@angular/core';
 import { Injector, OnInit, Signal, TemplateRef, Type } from '@angular/core';
 import { MessagePart, ToolCallPart, UIMessage } from '@tanstack/ai';
+import { z } from 'zod';
 
+declare const runRecordSchema: z.ZodObject<{
+	id: z.ZodUUID;
+	threadId: z.ZodNullable<z.ZodUUID>;
+	inputId: z.ZodNullable<z.ZodUUID>;
+	kind: z.ZodEnum<{
+		turn: "turn";
+		subagent: "subagent";
+		tool: "tool";
+	}>;
+	subagentRunId: z.ZodNullable<z.ZodString>;
+	status: z.ZodEnum<{
+		running: "running";
+		waiting: "waiting";
+		completed: "completed";
+		failed: "failed";
+		cancelled: "cancelled";
+	}>;
+	reason: z.ZodNullable<z.ZodEnum<{
+		cancelled: "cancelled";
+		no_output: "no_output";
+		invalid_output: "invalid_output";
+		stopped: "stopped";
+		parent_cancelled: "parent_cancelled";
+		lost: "lost";
+		timeout: "timeout";
+	}>>;
+	result: z.ZodUnknown;
+	waits: z.ZodArray<z.ZodObject<{
+		kind: z.ZodEnum<{
+			approval: "approval";
+			client_tool: "client_tool";
+		}>;
+		toolCallId: z.ZodString;
+		toolName: z.ZodString;
+		input: z.ZodUnknown;
+	}, z.core.$strip>>;
+	createdAt: z.ZodISODateTime;
+	finishedAt: z.ZodNullable<z.ZodISODateTime>;
+}, z.core.$strip>;
+export type RunRecord = z.infer<typeof runRecordSchema>;
 declare const LOCALES: readonly [
 	"en",
 	"ar"
 ];
 export type Locale = (typeof LOCALES)[number];
+declare const TOOL_SURFACES: readonly [
+	"inline",
+	"modal"
+];
+export type ToolSurface = (typeof TOOL_SURFACES)[number];
 declare const MESSAGE_ROLES: readonly [
 	"system",
 	"user",
 	"assistant",
-	"trigger"
+	"event"
 ];
 export type MessageRole = (typeof MESSAGE_ROLES)[number];
+declare const WHILE_BUSY: readonly [
+	"refuse",
+	"queue",
+	"steer"
+];
+export type WhileBusy = (typeof WHILE_BUSY)[number];
+declare const MESSAGE_BUSY: readonly [
+	"queue",
+	"steer"
+];
+export type MessageBusy = (typeof MESSAGE_BUSY)[number];
 declare const ATTACHMENT_STATUSES: readonly [
 	"pending",
 	"described",
@@ -61,6 +118,14 @@ export type ThreadSummary = {
 export type CreateThreadRequest = {
 	variables?: Record<string, string | number | boolean>;
 };
+/**
+ * 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 = {
+	aborted: boolean;
+};
 export type TokenUsage = {
 	input: {
 		noCache: number;
@@ -75,6 +140,17 @@ export type TokenUsage = {
 	};
 	total: number;
 };
+/**
+ * Response of `GET /connections/:server?call=<toolCallId>`: where the
+ * caller's own account stands with the agent's MCP server of that name, for
+ * the card of that `connectAccount` call. `connected` with all a sign-in
+ * may ask for; `pending` while it is not connected, or lacks access a
+ * sign-in may still grant; `refused` once the card's own sign-in came back
+ * without it, or no sign-in may ask again.
+ */
+export type AccountConnection = {
+	status: "connected" | "pending" | "refused";
+};
 /**
  * What Cortex offers this agent's clients, fetched once at widget startup.
  * The widget hides UI for anything absent; Cortex enforces each.
@@ -91,6 +167,8 @@ export type AgentCapabilities = {
 	messages: boolean;
 	/** True when the caller only reads, as an operator inspecting a user's thread does. */
 	readOnly: boolean;
+	/** What a message sent while a run holds the thread does; under `refuse`, nothing sends until the run ends. */
+	whileBusy: WhileBusy;
 	/** Prompt chips on the blank-chat landing per locale; clicking one sends its `prompt` as the first message. */
 	suggestions: Suggestions;
 	/** Headline of the blank-chat landing per locale; "" falls back to the widget's built-in copy. */
@@ -109,8 +187,8 @@ export type MessageMetadata = {
 	isAborted?: boolean;
 	tokenUsage?: TokenUsage;
 	attachments?: AttachmentSummary[];
-	/** Set on `trigger` messages: the firing that wrote them. */
-	trigger?: TriggerFiringSummary;
+	/** Set on `event` messages: what happened, and the input that brought it. */
+	event?: EventSummary;
 };
 /**
  * One landing-page chip: the widget shows `title` and sends `prompt` as the
@@ -125,11 +203,16 @@ export type Suggestions = Record<Locale, Suggestion[]>;
 export type Greeting = Record<Locale, string>;
 /** Author-written copy the widget shows verbatim, one string per locale. */
 export type LocalizedText = Record<Locale, string>;
-export type TriggerFiringSummary = {
+/** An event that entered a conversation: a trigger fired, a schedule came due, a run finished. */
+export type EventSummary = {
+	source: "trigger" | "schedule" | "run";
+	/** The trigger's name, or what the schedule or run was for. */
 	name: string;
-	firingId: string;
-	firedAt: string;
+	inputId: string;
+	at: string;
 	payload: unknown;
+	/** What a trigger that leaves a note tells the thread, for its user to read. */
+	note?: string;
 };
 /**
  * A stored message as it is persisted and served: the SDK's parts plus the
@@ -142,35 +225,53 @@ export type TriggerFiringSummary = {
  */
 export type CortexMessage<TPart = unknown> = {
 	id: string;
-	/** `trigger` rows carry a firing's instructions; the UIs render them as an event, not a bubble. */
+	/** `event` rows carry what happened; 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`.
+ * 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 ChatDropped = {
-	outcome: "dropped";
-	reason: Exclude<TriggerDropReason, "budget"> | "no_turn";
+export type ClientToolInitiateResult = {
+	embedUrl: string;
+	surface: ToolSurface;
+	embedOrigin: string;
 };
 /**
- * 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.
+ * One input waiting on a thread, in the order dispatch takes them, in
+ * `GET /threads/:threadId/inputs`: the user message as it will be stored
+ * once a run takes it up, and how it waits: to steer the running turn, or
+ * for a turn of its own. `DELETE /threads/:threadId/inputs/:inputId`
+ * cancels it and `PATCH` (`{ busy }`) moves it to steer or queue, unless a
+ * run already took it in (404).
+ */
+export type WaitingInput<TPart = unknown> = {
+	inputId: string;
+	delivery: "prompt" | "steer" | "followUp" | "answer" | "note";
+	message: CortexMessage<TPart>;
+	/** Whether it is text alone, which a running turn may take in as a steer; one with files waits for a turn of its own. */
+	textOnly: boolean;
+};
+/**
+ * The refusal 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
+ * refusal shows as a failed turn.
+ */
+export type SendRefusal = "approval_pending";
+/**
+ * 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 SendRefusal = Extract<ChatDropped["reason"], "approval_pending">;
+export type LlmRequest = {
+	id: string;
+	prompt: string;
+	output: string | null;
+	tokenUsage: TokenUsage | null;
+};
 export type CortexHeaders = Record<string, string>;
 /**
  * How the widget reaches Cortex. `baseUrl` may be a thunk so a consumer with
@@ -192,6 +293,8 @@ export type CortexTransport = {
 	 */
 	threadBody?: CreateThreadRequest;
 };
+/** A message as Cortex serves it: SDK parts plus Cortex's metadata envelope. */
+export type CortexChatMessage = CortexMessage<MessagePart>;
 export type ColorScheme = "light" | "dark";
 export type MediaRenderContext = {
 	scheme: ColorScheme;
@@ -386,6 +489,16 @@ export type ChatSessionState = {
 	awaitsApproval: boolean;
 	/** The last turn failed: Cortex said its run failed, or the message never got out. */
 	turnFailure: TurnFailure | undefined;
+	/**
+	 * Messages sent while a run worked that wait on the thread, in the order
+	 * Cortex takes them, each with its input to cancel it by and how it
+	 * waits; one leaves once the transcript holds it.
+	 */
+	queued: QueuedItem[];
+};
+/** A message waiting on the thread, the input it waits as, and how. */
+export type QueuedItem = Omit<WaitingInput, "message"> & {
+	message: UIMessage;
 };
 /** Everything a widget draws, the same for every framework. */
 export type CortexWidgetState = {
@@ -413,7 +526,23 @@ export type CortexWidgetState = {
 	attachments: QueuedAttachment[];
 	/** A thread is being created for the message on its way out; the composer waits for it. */
 	creating: boolean;
-	screen: "chat" | "threads";
+	/** Where the reader picked to send the message being written while a run works; unset, the agent's busy rule (`composerBusy`). It lasts for one message, and ends with its run or on leaving the thread. */
+	busyPick: MessageBusy | undefined;
+	/** What the widget read of the copies the transcript's cards name: each one's latest run, by subagent run id. */
+	copies: Readonly<Record<string, RunRecord>>;
+	/** The check-backs the reader cancelled here, by their input id, so their lines say so (`checkBackLine`). */
+	cancelledCheckBacks: readonly string[];
+	/**
+	 * The copy whose own thread this state has open, on the state its screen
+	 * draws (`copyScreen`): its subagent run id, and whether its composer
+	 * takes focus as the screen opens. Unset on the widget's own state.
+	 */
+	copy: {
+		id: string;
+		focus: boolean;
+	} | undefined;
+	/** `copy`: a copy's screen covers the chat it was opened from (`openCopy`). */
+	screen: "chat" | "threads" | "copy";
 	/** 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. */
@@ -427,149 +556,83 @@ export type CortexWidgetState = {
 		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",
-	"failed",
-	"skipped"
-];
-type AttachmentStatus$1 = (typeof ATTACHMENT_STATUSES$1)[number];
-declare const ATTACHMENT_ORIGINS$1: readonly [
-	"upload",
-	"tool"
-];
-type AttachmentOrigin$1 = (typeof ATTACHMENT_ORIGINS$1)[number];
-export type AttachmentSummary$1 = {
-	id: string;
-	filename: string;
-	contentType: string;
-	sizeBytes: number;
-	status: AttachmentStatus$1;
-	origin: AttachmentOrigin$1;
-	description: string | null;
-};
-/**
- * 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;
-};
-type TokenUsage$1 = {
-	input: {
-		noCache: number;
-		cacheRead: number;
-		cacheWrite: number;
-		total: number;
-	};
-	output: {
-		reasoning: number;
-		text: number;
-		total: number;
-	};
-	total: number;
-};
-/**
- * Response of `GET /connections/:server?call=<toolCallId>`: where the
- * caller's own account stands with the agent's MCP server of that name, for
- * the card of that `connectAccount` call. `connected` with all a sign-in
- * may ask for; `pending` while it is not connected, or lacks access a
- * sign-in may still grant; `refused` once the card's own sign-in came back
- * without it, or no sign-in may ask again.
- */
-export type AccountConnection$1 = {
-	status: "connected" | "pending" | "refused";
-};
-/**
- * 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 = {
-	/** The agent's display name per locale, which titles a new chat; `{}` for an agent without one. */
-	displayName: Partial<LocalizedText$1>;
-	attachments: boolean;
-	/**
-	 * 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.
-	 */
-	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;
-	/**
-	 * 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.
-	 */
-	debug: boolean;
-};
-type Suggestion$1 = {
-	title: string;
-	prompt: string;
-};
-type Suggestions$1 = Record<Locale$1, Suggestion$1[]>;
-type Greeting$1 = Record<Locale$1, string>;
-type LocalizedText$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: {
+declare function createCortexWidget(options: {
+	/** The consumer's config, read at each use so a change lands. */
+	getConfig: () => CortexConfig;
+}): {
+	copyScreen: {
+		getState: () => CortexWidgetState;
+		getDraft: () => string;
+		setDraft: (next: string) => void;
+		submit: (text: string) => Promise<{
+			readonly sent: false;
+			readonly text: string;
+		} | {
+			readonly sent: true;
+		}>;
+		sendDraft: (launch: (text: string) => void) => void;
+		abort: () => Promise<void>;
+		cancelQueued: (inputId: string) => Promise<void>;
+		sendQueuedNow: (inputId: string) => Promise<void>;
+		addToolResult: () => Promise<void>;
+		respondToApproval: () => Promise<void>;
+		/** Cortex's API for this widget's agent, reading the transport off the config at every call. */
 		api: {
 			onVisitorReplaced(heard: () => void): () => void;
 			retrySignIn(): void;
-			getCapabilities(): Promise<AgentCapabilities$1>;
+			getCapabilities(): Promise<AgentCapabilities>;
 			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>;
-			accountConnection(server: string, toolCallId: string, signal?: AbortSignal): Promise<AccountConnection$1>;
-			uploadAttachment(threadId: string, file: File): Promise<AttachmentSummary$1>;
+			listLlmRequests(threadId: string, messageId: string): Promise<LlmRequest[]>;
+			abortStream(threadId: string): Promise<AbortRunResult>;
+			queueMessage(threadId: string, runId: string, message: {
+				id: string;
+				content: string;
+				metadata: MessageMetadata;
+			}, busy?: MessageBusy): Promise<{
+				inputId: string;
+				state: "waiting";
+				delivery: "prompt" | "steer" | "followUp" | "answer" | "note";
+			} | {
+				inputId: string | null;
+				state: "refused";
+				reason: "busy" | "approval_pending" | "conflict" | "rate_limited" | "budget" | "full" | "not_waiting";
+			} | {
+				inputId: string;
+				state: "cancelled";
+				reason: "stopped";
+			} | {
+				readonly state: "started";
+			}>;
+			listInputs(threadId: string): Promise<WaitingInput<import("@tanstack/ai").MessagePart>[]>;
+			cancelInput(threadId: string, inputId: string): Promise<void>;
+			moveInput(threadId: string, inputId: string, busy: MessageBusy): Promise<void>;
+			getRun(id: string): Promise<{
+				id: string;
+				threadId: string | null;
+				inputId: string | null;
+				kind: "turn" | "subagent" | "tool";
+				subagentRunId: string | null;
+				status: "running" | "waiting" | "completed" | "failed" | "cancelled";
+				reason: "cancelled" | "no_output" | "invalid_output" | "stopped" | "parent_cancelled" | "lost" | "timeout" | null;
+				result: unknown;
+				waits: {
+					kind: "approval" | "client_tool";
+					toolCallId: string;
+					toolName: string;
+					input: unknown;
+				}[];
+				createdAt: string;
+				finishedAt: string | null;
+			}>;
+			cancelRun(id: string): Promise<{
+				cancelled: boolean;
+			}>;
+			initiateToolCall(threadId: string, toolCallId: string): Promise<ClientToolInitiateResult>;
+			accountConnection(server: string, toolCallId: string, signal?: AbortSignal): Promise<AccountConnection>;
+			uploadAttachment(threadId: string, file: File): Promise<AttachmentSummary>;
 			deleteAttachment(id: string): Promise<void>;
 			downloadAttachment(id: string): Promise<{
 				blob: Blob;
@@ -581,22 +644,39 @@ declare class CortexChatService {
 			resolveUrl: (path: string) => string;
 			readVisitorAnswer: (response: Response, sent: HeadersInit | undefined) => "refused" | "stale" | undefined;
 		};
-		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>;
+		/**
+		 * Cancels a check-back the agent scheduled on the open thread, by its
+		 * input id: its line says so at once, and again as it was once Cortex
+		 * refuses (the check-back came due first).
+		 */
+		cancelCheckBack(inputId: string): Promise<void>;
+		/** Picks where the message being written goes while a run works (`composerBusy`). */
+		pickBusy: (busy: MessageBusy) => void;
+		/** Reads a copy's run, as its card asks (`subagentCard`'s `readsRun`). */
+		readCopy: (id: string) => Promise<{
+			id: string;
+			threadId: string | null;
+			inputId: string | null;
+			kind: "turn" | "subagent" | "tool";
+			subagentRunId: string | null;
+			status: "running" | "waiting" | "completed" | "failed" | "cancelled";
+			reason: "cancelled" | "no_output" | "invalid_output" | "stopped" | "parent_cancelled" | "lost" | "timeout" | null;
+			result: unknown;
+			waits: {
+				kind: "approval" | "client_tool";
+				toolCallId: string;
+				toolName: string;
+				input: unknown;
+			}[];
+			createdAt: string;
+			finishedAt: string | null;
+		} | undefined>;
+		cancelCopy: (id: string) => Promise<void>;
+		openCopy: (id: string, focus?: boolean) => void;
+		closeCopy: () => void;
 		openThread: (thread: ThreadSummary) => void;
 		newChat: () => void;
 		deleteThread: (threadId: string) => Promise<void>;
@@ -605,8 +685,150 @@ declare class CortexChatService {
 		openHistory: () => void;
 		closeHistory: () => void;
 		toggleDebug: () => void;
+		/** Asks Cortex everything again now, signing in afresh, as a visitor the reCAPTCHA check refused does on "Try again". */
 		retry: () => void;
 	};
+	/** Cortex's API for this widget's agent, reading the transport off the config at every call. */
+	api: {
+		onVisitorReplaced(heard: () => void): () => void;
+		retrySignIn(): void;
+		getCapabilities(): Promise<AgentCapabilities>;
+		listThreads(): Promise<ThreadSummary[]>;
+		createThread(): Promise<ThreadSummary>;
+		deleteThread(threadId: string): Promise<void>;
+		listMessages(threadId: string): Promise<CortexChatMessage[]>;
+		listLlmRequests(threadId: string, messageId: string): Promise<LlmRequest[]>;
+		abortStream(threadId: string): Promise<AbortRunResult>;
+		queueMessage(threadId: string, runId: string, message: {
+			id: string;
+			content: string;
+			metadata: MessageMetadata;
+		}, busy?: MessageBusy): Promise<{
+			inputId: string;
+			state: "waiting";
+			delivery: "prompt" | "steer" | "followUp" | "answer" | "note";
+		} | {
+			inputId: string | null;
+			state: "refused";
+			reason: "busy" | "approval_pending" | "conflict" | "rate_limited" | "budget" | "full" | "not_waiting";
+		} | {
+			inputId: string;
+			state: "cancelled";
+			reason: "stopped";
+		} | {
+			readonly state: "started";
+		}>;
+		listInputs(threadId: string): Promise<WaitingInput<import("@tanstack/ai").MessagePart>[]>;
+		cancelInput(threadId: string, inputId: string): Promise<void>;
+		moveInput(threadId: string, inputId: string, busy: MessageBusy): Promise<void>;
+		getRun(id: string): Promise<{
+			id: string;
+			threadId: string | null;
+			inputId: string | null;
+			kind: "turn" | "subagent" | "tool";
+			subagentRunId: string | null;
+			status: "running" | "waiting" | "completed" | "failed" | "cancelled";
+			reason: "cancelled" | "no_output" | "invalid_output" | "stopped" | "parent_cancelled" | "lost" | "timeout" | null;
+			result: unknown;
+			waits: {
+				kind: "approval" | "client_tool";
+				toolCallId: string;
+				toolName: string;
+				input: unknown;
+			}[];
+			createdAt: string;
+			finishedAt: string | null;
+		}>;
+		cancelRun(id: string): Promise<{
+			cancelled: boolean;
+		}>;
+		initiateToolCall(threadId: string, toolCallId: string): Promise<ClientToolInitiateResult>;
+		accountConnection(server: string, toolCallId: string, signal?: AbortSignal): Promise<AccountConnection>;
+		uploadAttachment(threadId: string, file: File): Promise<AttachmentSummary>;
+		deleteAttachment(id: string): Promise<void>;
+		downloadAttachment(id: string): Promise<{
+			blob: Blob;
+			name: string;
+		}>;
+		resolveHeaders: () => Promise<{
+			[x: string]: string;
+		}>;
+		resolveUrl: (path: string) => string;
+		readVisitorAnswer: (response: Response, sent: HeadersInit | undefined) => "refused" | "stale" | undefined;
+	};
+	getState: () => CortexWidgetState;
+	getDraft: () => string;
+	subscribe: (listener: () => void) => () => void;
+	start: () => void;
+	stop: () => void;
+	setDraft: (next: string) => void;
+	submit: (text: string, busy?: MessageBusy) => Promise<{
+		readonly sent: false;
+		readonly text: string;
+	} | {
+		readonly sent: true;
+	}>;
+	sendDraft: (launch: (text: string) => void) => void;
+	abort: () => Promise<void>;
+	/** Cancels a message waiting on the open thread. */
+	cancelQueued: (inputId: string) => Promise<void>;
+	/**
+	 * Cancels a check-back the agent scheduled on the open thread, by its
+	 * input id: its line says so at once, and again as it was once Cortex
+	 * refuses (the check-back came due first).
+	 */
+	cancelCheckBack(inputId: string): Promise<void>;
+	/** Sends a message queued on the open thread now, into the running turn. */
+	sendQueuedNow: (inputId: string) => Promise<void>;
+	/** Picks where the message being written goes while a run works (`composerBusy`). */
+	pickBusy: (busy: MessageBusy) => void;
+	/** Reads a copy's run, as its card asks (`subagentCard`'s `readsRun`). */
+	readCopy: (id: string) => Promise<{
+		id: string;
+		threadId: string | null;
+		inputId: string | null;
+		kind: "turn" | "subagent" | "tool";
+		subagentRunId: string | null;
+		status: "running" | "waiting" | "completed" | "failed" | "cancelled";
+		reason: "cancelled" | "no_output" | "invalid_output" | "stopped" | "parent_cancelled" | "lost" | "timeout" | null;
+		result: unknown;
+		waits: {
+			kind: "approval" | "client_tool";
+			toolCallId: string;
+			toolName: string;
+			input: unknown;
+		}[];
+		createdAt: string;
+		finishedAt: string | null;
+	} | undefined>;
+	cancelCopy: (id: string) => Promise<void>;
+	openCopy: (id: string, focus?: boolean) => void;
+	closeCopy: () => void;
+	addToolResult: (toolCallId: string, toolName: string, output: unknown) => Promise<void>;
+	respondToApproval: (call: 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;
+	/** Asks Cortex everything again now, signing in afresh, as a visitor the reCAPTCHA check refused does on "Try again". */
+	retry: () => void;
+};
+/** The widget as a screen draws it: its own, or as a copy's screen has it (`copyScreen`). */
+export type CortexWidget = Omit<ReturnType<typeof createCortexWidget>, "copyScreen">;
+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 class CortexChatService {
+	readonly widget: CortexWidget;
 	private readonly snapshot;
 	private readonly text;
 	readonly state: import("@angular/core").Signal<CortexWidgetState>;
@@ -685,7 +907,6 @@ export declare class CortexChatWidgetComponent implements OnInit {
 			openThread: (thread: ThreadSummary) => void;
 		};
 	}>;
-	protected readonly composerSlot: import("@angular/core").Signal<"translate_access_refused" | "translate_visitor_unverified" | "translate_agent_unreachable" | "translate_agent_missing" | "composer" | "translate_read_only" | "translate_messages_disabled" | undefined>;
 	private readonly injector;
 	constructor();
 	ngOnInit(): void;