@keyueclaw/web-sdk 0.1.84 → 0.1.85

package/dist/src/utils/queue-helpers.d.ts

@@ -0,0 +1,80 @@
+export type QueueSummaryState = {
+    dropPolicy: "summarize" | "old" | "new";
+    droppedCount: number;
+    summaryLines: string[];
+};
+export type QueueDropPolicy = QueueSummaryState["dropPolicy"];
+export type QueueState<T> = QueueSummaryState & {
+    items: T[];
+    cap: number;
+};
+export declare function clearQueueSummaryState(state: QueueSummaryState): void;
+export declare function previewQueueSummaryPrompt(params: {
+    state: QueueSummaryState;
+    noun: string;
+    title?: string;
+}): string | undefined;
+export declare function applyQueueRuntimeSettings<TMode extends string>(params: {
+    target: {
+        mode: TMode;
+        debounceMs: number;
+        cap: number;
+        dropPolicy: QueueDropPolicy;
+    };
+    settings: {
+        mode: TMode;
+        debounceMs?: number;
+        cap?: number;
+        dropPolicy?: QueueDropPolicy;
+    };
+}): void;
+export declare function elideQueueText(text: string, limit?: number): string;
+export declare function buildQueueSummaryLine(text: string, limit?: number): string;
+export declare function shouldSkipQueueItem<T>(params: {
+    item: T;
+    items: T[];
+    dedupe?: (item: T, items: T[]) => boolean;
+}): boolean;
+export declare function applyQueueDropPolicy<T>(params: {
+    queue: QueueState<T>;
+    summarize: (item: T) => string;
+    summaryLimit?: number;
+}): boolean;
+export declare function waitForQueueDebounce(queue: {
+    debounceMs: number;
+    lastEnqueuedAt: number;
+}): Promise<void>;
+export declare function beginQueueDrain<T extends {
+    draining: boolean;
+}>(map: Map<string, T>, key: string): T | undefined;
+export declare function drainNextQueueItem<T>(items: T[], run: (item: T) => Promise<void>): Promise<boolean>;
+export declare function drainCollectItemIfNeeded<T>(params: {
+    forceIndividualCollect: boolean;
+    isCrossChannel: boolean;
+    setForceIndividualCollect?: (next: boolean) => void;
+    items: T[];
+    run: (item: T) => Promise<void>;
+}): Promise<"skipped" | "drained" | "empty">;
+export declare function drainCollectQueueStep<T>(params: {
+    collectState: {
+        forceIndividualCollect: boolean;
+    };
+    isCrossChannel: boolean;
+    items: T[];
+    run: (item: T) => Promise<void>;
+}): Promise<"skipped" | "drained" | "empty">;
+export declare function buildQueueSummaryPrompt(params: {
+    state: QueueSummaryState;
+    noun: string;
+    title?: string;
+}): string | undefined;
+export declare function buildCollectPrompt<T>(params: {
+    title: string;
+    items: T[];
+    summary?: string;
+    renderItem: (item: T, index: number) => string;
+}): string;
+export declare function hasCrossChannelItems<T>(items: T[], resolveKey: (item: T) => {
+    key?: string;
+    cross?: boolean;
+}): boolean;

package/dist/src/utils/run-with-concurrency.d.ts

@@ -0,0 +1,11 @@
+export type ConcurrencyErrorMode = "continue" | "stop";
+export declare function runTasksWithConcurrency<T>(params: {
+    tasks: Array<() => Promise<T>>;
+    limit: number;
+    errorMode?: ConcurrencyErrorMode;
+    onTaskError?: (error: unknown, index: number) => void;
+}): Promise<{
+    results: T[];
+    firstError: unknown;
+    hasError: boolean;
+}>;

package/dist/src/utils/safe-json.d.ts

@@ -0,0 +1 @@
+export declare function safeJsonStringify(value: unknown): string | null;

package/dist/src/utils/shell-argv.d.ts

@@ -0,0 +1 @@
+export declare function splitShellArgs(raw: string): string[] | null;

package/dist/src/utils/transcript-tools.d.ts

@@ -0,0 +1,8 @@
+type ToolResultCounts = {
+    total: number;
+    errors: number;
+};
+export declare const extractToolCallNames: (message: Record<string, unknown>) => string[];
+export declare const hasToolCall: (message: Record<string, unknown>) => boolean;
+export declare const countToolResults: (message: Record<string, unknown>) => ToolResultCounts;
+export {};

package/dist/src/utils/usage-format.d.ts

@@ -0,0 +1,26 @@
+import type { NormalizedUsage } from "../agents/usage.js";
+import type { OpenClawConfig } from "../config/config.js";
+export type ModelCostConfig = {
+    input: number;
+    output: number;
+    cacheRead: number;
+    cacheWrite: number;
+};
+export type UsageTotals = {
+    input?: number;
+    output?: number;
+    cacheRead?: number;
+    cacheWrite?: number;
+    total?: number;
+};
+export declare function formatTokenCount(value?: number): string;
+export declare function formatUsd(value?: number): string | undefined;
+export declare function resolveModelCostConfig(params: {
+    provider?: string;
+    model?: string;
+    config?: OpenClawConfig;
+}): ModelCostConfig | undefined;
+export declare function estimateUsageCost(params: {
+    usage?: NormalizedUsage | UsageTotals | null;
+    cost?: ModelCostConfig;
+}): number | undefined;

package/dist/src/utils/with-timeout.d.ts

@@ -0,0 +1 @@
+export declare function withTimeout<T>(promise: Promise<T>, timeoutMs: number): Promise<T>;

package/dist/src/utils.d.ts

@@ -0,0 +1,61 @@
+import { isPlainObject } from "./infra/plain-object.js";
+export declare function ensureDir(dir: string): Promise<void>;
+/**
+ * Check if a file or directory exists at the given path.
+ */
+export declare function pathExists(targetPath: string): Promise<boolean>;
+export declare function clampNumber(value: number, min: number, max: number): number;
+export declare function clampInt(value: number, min: number, max: number): number;
+/** Alias for clampNumber (shorter, more common name) */
+export declare const clamp: typeof clampNumber;
+/**
+ * Escapes special regex characters in a string so it can be used in a RegExp constructor.
+ */
+export declare function escapeRegExp(value: string): string;
+/**
+ * Safely parse JSON, returning null on error instead of throwing.
+ */
+export declare function safeParseJson<T>(raw: string): T | null;
+export { isPlainObject };
+/**
+ * Type guard for Record<string, unknown> (less strict than isPlainObject).
+ * Accepts any non-null object that isn't an array.
+ */
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+export type WebChannel = "web";
+export declare function assertWebChannel(input: string): asserts input is WebChannel;
+export declare function normalizeE164(number: string): string;
+/**
+ * "Self-chat mode" heuristic (single phone): the gateway is logged in as the owner's own WhatsApp account,
+ * and `channels.whatsapp.allowFrom` includes that same number. Used to avoid side-effects that make no sense when the
+ * "bot" and the human are the same WhatsApp identity (e.g. auto read receipts, @mention JID triggers).
+ */
+export declare function isSelfChatMode(selfE164: string | null | undefined, allowFrom?: Array<string | number> | null): boolean;
+export declare function toWhatsappJid(number: string): string;
+export type JidToE164Options = {
+    authDir?: string;
+    lidMappingDirs?: string[];
+    logMissing?: boolean;
+};
+type LidLookup = {
+    getPNForLID?: (jid: string) => Promise<string | null>;
+};
+export declare function jidToE164(jid: string, opts?: JidToE164Options): string | null;
+export declare function resolveJidToE164(jid: string | null | undefined, opts?: JidToE164Options & {
+    lidLookup?: LidLookup;
+}): Promise<string | null>;
+export declare function sleep(ms: number): Promise<unknown>;
+export declare function sliceUtf16Safe(input: string, start: number, end?: number): string;
+export declare function truncateUtf16Safe(input: string, maxLen: number): string;
+export declare function resolveUserPath(input: string, env?: NodeJS.ProcessEnv, homedir?: () => string): string;
+export declare function resolveConfigDir(env?: NodeJS.ProcessEnv, homedir?: () => string): string;
+export declare function resolveHomeDir(): string | undefined;
+export declare function shortenHomePath(input: string): string;
+export declare function shortenHomeInString(input: string): string;
+export declare function displayPath(input: string): string;
+export declare function displayString(input: string): string;
+export declare function formatTerminalLink(label: string, url: string, opts?: {
+    fallback?: string;
+    force?: boolean;
+}): string;
+export declare const CONFIG_DIR: string;

package/dist/src/version.d.ts

@@ -0,0 +1,16 @@
+export declare function readVersionFromPackageJsonForModuleUrl(moduleUrl: string): string | null;
+export declare function readVersionFromBuildInfoForModuleUrl(moduleUrl: string): string | null;
+export declare function resolveVersionFromModuleUrl(moduleUrl: string): string | null;
+export declare function resolveBinaryVersion(params: {
+    moduleUrl: string;
+    injectedVersion?: string;
+    bundledVersion?: string;
+    fallback?: string;
+}): string;
+export type RuntimeVersionEnv = {
+    [key: string]: string | undefined;
+};
+export declare const RUNTIME_SERVICE_VERSION_FALLBACK = "unknown";
+export declare function resolveUsableRuntimeVersion(version: string | undefined): string | undefined;
+export declare function resolveRuntimeServiceVersion(env?: RuntimeVersionEnv, fallback?: string): string;
+export declare const VERSION: string;

package/dist/src/web-search/runtime.d.ts

@@ -0,0 +1,41 @@
+import type { OpenClawConfig } from "../config/config.js";
+import type { PluginWebSearchProviderEntry, WebSearchProviderToolDefinition } from "../plugins/types.js";
+import type { RuntimeWebSearchMetadata } from "../secrets/runtime-web-tools.types.js";
+type WebSearchConfig = NonNullable<OpenClawConfig["tools"]>["web"] extends infer Web ? Web extends {
+    search?: infer Search;
+} ? Search : undefined : undefined;
+export type ResolveWebSearchDefinitionParams = {
+    config?: OpenClawConfig;
+    sandboxed?: boolean;
+    runtimeWebSearch?: RuntimeWebSearchMetadata;
+    providerId?: string;
+    preferRuntimeProviders?: boolean;
+};
+export type RunWebSearchParams = ResolveWebSearchDefinitionParams & {
+    args: Record<string, unknown>;
+};
+declare function resolveSearchConfig(cfg?: OpenClawConfig): WebSearchConfig;
+export declare function resolveWebSearchEnabled(params: {
+    search?: WebSearchConfig;
+    sandboxed?: boolean;
+}): boolean;
+export declare function listWebSearchProviders(params?: {
+    config?: OpenClawConfig;
+}): PluginWebSearchProviderEntry[];
+export declare function resolveWebSearchProviderId(params: {
+    search?: WebSearchConfig;
+    providers?: PluginWebSearchProviderEntry[];
+}): string;
+export declare function resolveWebSearchDefinition(options?: ResolveWebSearchDefinitionParams): {
+    provider: PluginWebSearchProviderEntry;
+    definition: WebSearchProviderToolDefinition;
+} | null;
+export declare function runWebSearch(params: RunWebSearchParams): Promise<{
+    provider: string;
+    result: Record<string, unknown>;
+}>;
+export declare const __testing: {
+    resolveSearchConfig: typeof resolveSearchConfig;
+    resolveWebSearchProviderId: typeof resolveWebSearchProviderId;
+};
+export {};

package/dist/src/whatsapp/normalize.d.ts

@@ -0,0 +1,6 @@
+export declare function isWhatsAppGroupJid(value: string): boolean;
+/**
+ * Check if value looks like a WhatsApp user target (e.g. "41796666864:0@s.whatsapp.net" or "123@lid").
+ */
+export declare function isWhatsAppUserTarget(value: string): boolean;
+export declare function normalizeWhatsAppTarget(value: string): string | null;

package/dist/src/whatsapp/resolve-outbound-target.d.ts

@@ -0,0 +1,12 @@
+export type WhatsAppOutboundTargetResolution = {
+    ok: true;
+    to: string;
+} | {
+    ok: false;
+    error: Error;
+};
+export declare function resolveWhatsAppOutboundTarget(params: {
+    to: string | null | undefined;
+    allowFrom: Array<string | number> | null | undefined;
+    mode: string | null | undefined;
+}): WhatsAppOutboundTargetResolution;

package/dist/src/wizard/prompts.d.ts

@@ -0,0 +1,43 @@
+export type WizardSelectOption<T = string> = {
+    value: T;
+    label: string;
+    hint?: string;
+};
+export type WizardSelectParams<T = string> = {
+    message: string;
+    options: Array<WizardSelectOption<T>>;
+    initialValue?: T;
+};
+export type WizardMultiSelectParams<T = string> = {
+    message: string;
+    options: Array<WizardSelectOption<T>>;
+    initialValues?: T[];
+    searchable?: boolean;
+};
+export type WizardTextParams = {
+    message: string;
+    initialValue?: string;
+    placeholder?: string;
+    validate?: (value: string) => string | undefined;
+};
+export type WizardConfirmParams = {
+    message: string;
+    initialValue?: boolean;
+};
+export type WizardProgress = {
+    update: (message: string) => void;
+    stop: (message?: string) => void;
+};
+export type WizardPrompter = {
+    intro: (title: string) => Promise<void>;
+    outro: (message: string) => Promise<void>;
+    note: (message: string, title?: string) => Promise<void>;
+    select: <T>(params: WizardSelectParams<T>) => Promise<T>;
+    multiselect: <T>(params: WizardMultiSelectParams<T>) => Promise<T[]>;
+    text: (params: WizardTextParams) => Promise<string>;
+    confirm: (params: WizardConfirmParams) => Promise<boolean>;
+    progress: (label: string) => WizardProgress;
+};
+export declare class WizardCancelledError extends Error {
+    constructor(message?: string);
+}

package/dist/src/wizard/session.d.ts

@@ -0,0 +1,42 @@
+import { type WizardPrompter } from "./prompts.js";
+export type WizardStepOption = {
+    value: unknown;
+    label: string;
+    hint?: string;
+};
+export type WizardStep = {
+    id: string;
+    type: "note" | "select" | "text" | "confirm" | "multiselect" | "progress" | "action";
+    title?: string;
+    message?: string;
+    options?: WizardStepOption[];
+    initialValue?: unknown;
+    placeholder?: string;
+    sensitive?: boolean;
+    executor?: "gateway" | "client";
+};
+export type WizardSessionStatus = "running" | "done" | "cancelled" | "error";
+export type WizardNextResult = {
+    done: boolean;
+    step?: WizardStep;
+    status: WizardSessionStatus;
+    error?: string;
+};
+export declare class WizardSession {
+    private runner;
+    private currentStep;
+    private stepDeferred;
+    private answerDeferred;
+    private status;
+    private error;
+    constructor(runner: (prompter: WizardPrompter) => Promise<void>);
+    next(): Promise<WizardNextResult>;
+    answer(stepId: string, value: unknown): Promise<void>;
+    cancel(): void;
+    pushStep(step: WizardStep): void;
+    private run;
+    awaitAnswer(step: WizardStep): Promise<unknown>;
+    private resolveStep;
+    getStatus(): WizardSessionStatus;
+    getError(): string | undefined;
+}

package/dist/ui/src/i18n/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./lib/types.ts";
+export * from "./lib/translate.ts";
+export * from "./lib/lit-controller.ts";

package/dist/ui/src/i18n/lib/lit-controller.d.ts

@@ -0,0 +1,8 @@
+import type { ReactiveController, ReactiveControllerHost } from "lit";
+export declare class I18nController implements ReactiveController {
+    private host;
+    private unsubscribe?;
+    constructor(host: ReactiveControllerHost);
+    hostConnected(): void;
+    hostDisconnected(): void;
+}

package/dist/ui/src/i18n/lib/registry.d.ts

@@ -0,0 +1,6 @@
+import type { Locale, TranslationMap } from "./types.ts";
+export declare const DEFAULT_LOCALE: Locale;
+export declare const SUPPORTED_LOCALES: ReadonlyArray<Locale>;
+export declare function isSupportedLocale(value: string | null | undefined): value is Locale;
+export declare function resolveNavigatorLocale(navLang: string): Locale;
+export declare function loadLazyLocaleTranslation(locale: Locale): Promise<TranslationMap | null>;

package/dist/ui/src/i18n/lib/translate.d.ts

@@ -0,0 +1,22 @@
+import { SUPPORTED_LOCALES, isSupportedLocale } from "./registry.ts";
+import type { Locale, TranslationMap } from "./types.ts";
+type Subscriber = (locale: Locale) => void;
+export { SUPPORTED_LOCALES, isSupportedLocale };
+declare class I18nManager {
+    private locale;
+    private translations;
+    private subscribers;
+    constructor();
+    private readStoredLocale;
+    private persistLocale;
+    private resolveInitialLocale;
+    private loadLocale;
+    getLocale(): Locale;
+    setLocale(locale: Locale): Promise<void>;
+    registerTranslation(locale: Locale, map: TranslationMap): void;
+    subscribe(sub: Subscriber): () => boolean;
+    private notify;
+    t(key: string, params?: Record<string, string>): string;
+}
+export declare const i18n: I18nManager;
+export declare const t: (key: string, params?: Record<string, string>) => string;

package/dist/ui/src/i18n/lib/types.d.ts

@@ -0,0 +1,9 @@
+export type TranslationMap = {
+    [key: string]: string | TranslationMap;
+};
+export type Locale = "en" | "zh-CN" | "zh-TW" | "pt-BR" | "de" | "es";
+export interface I18nConfig {
+    locale: Locale;
+    fallbackLocale: Locale;
+    translations: Record<Locale, TranslationMap>;
+}

package/dist/ui/src/i18n/locales/de.d.ts

@@ -0,0 +1,2 @@
+import type { TranslationMap } from "../lib/types.ts";
+export declare const de: TranslationMap;

package/dist/ui/src/i18n/locales/en.d.ts

@@ -0,0 +1,2 @@
+import type { TranslationMap } from "../lib/types.ts";
+export declare const en: TranslationMap;

package/dist/ui/src/i18n/locales/es.d.ts

@@ -0,0 +1,2 @@
+import type { TranslationMap } from "../lib/types.ts";
+export declare const es: TranslationMap;

package/dist/ui/src/i18n/locales/pt-BR.d.ts

@@ -0,0 +1,2 @@
+import type { TranslationMap } from "../lib/types.ts";
+export declare const pt_BR: TranslationMap;

package/dist/ui/src/i18n/locales/zh-CN.d.ts

@@ -0,0 +1,2 @@
+import type { TranslationMap } from "../lib/types.ts";
+export declare const zh_CN: TranslationMap;

package/dist/ui/src/i18n/locales/zh-TW.d.ts

@@ -0,0 +1,2 @@
+import type { TranslationMap } from "../lib/types.ts";
+export declare const zh_TW: TranslationMap;

package/dist/ui/src/local-storage.d.ts

@@ -0,0 +1 @@
+export declare function getSafeLocalStorage(): Storage | null;

package/dist/ui/src/ui/admin.d.ts

@@ -0,0 +1,14 @@
+import type { ConfigSnapshot } from "./types.ts";
+type AdminCheckState = {
+    userPhone: string | null;
+    configForm: Record<string, unknown> | null;
+    configSnapshot: ConfigSnapshot | null;
+};
+/**
+ * 检查当前登录用户是否为超级管理员。
+ * openclaw.json 中配置 ui.adminPhones 字段（字符串数组），若当前手机号在列表中则为超管。
+ */
+export declare function isSuperAdmin(state: AdminCheckState): boolean;
+/** 仅超管可访问的 tab 列表 */
+export declare const ADMIN_ONLY_TABS: readonly ["skills", "jsonConfig", "modelSwitch", "payloadLogs", "apiManagement"];
+export {};

package/dist/ui/src/ui/app-channels.d.ts

@@ -0,0 +1,13 @@
+import type { OpenClawApp } from "./app.ts";
+import type { NostrProfile } from "./types.ts";
+export declare function handleWhatsAppStart(host: OpenClawApp, force: boolean): Promise<void>;
+export declare function handleWhatsAppWait(host: OpenClawApp): Promise<void>;
+export declare function handleWhatsAppLogout(host: OpenClawApp): Promise<void>;
+export declare function handleChannelConfigSave(host: OpenClawApp): Promise<void>;
+export declare function handleChannelConfigReload(host: OpenClawApp): Promise<void>;
+export declare function handleNostrProfileEdit(host: OpenClawApp, accountId: string, profile: NostrProfile | null): void;
+export declare function handleNostrProfileCancel(host: OpenClawApp): void;
+export declare function handleNostrProfileFieldChange(host: OpenClawApp, field: keyof NostrProfile, value: string): void;
+export declare function handleNostrProfileToggleAdvanced(host: OpenClawApp): void;
+export declare function handleNostrProfileSave(host: OpenClawApp): Promise<void>;
+export declare function handleNostrProfileImport(host: OpenClawApp): Promise<void>;

package/dist/ui/src/ui/app-chat.d.ts

@@ -0,0 +1,46 @@
+import type { OpenClawApp } from "./app.ts";
+import type { GatewayBrowserClient, GatewayHelloOk } from "./gateway.ts";
+import type { ChatModelOverride, ModelCatalogEntry } from "./types.ts";
+import type { ChatAttachment, ChatQueueItem } from "./ui-types.ts";
+export type ChatHost = {
+    client: GatewayBrowserClient | null;
+    chatMessages: unknown[];
+    chatStream: string | null;
+    connected: boolean;
+    chatLoading: boolean;
+    chatMessage: string;
+    chatAttachments: ChatAttachment[];
+    chatQueue: ChatQueueItem[];
+    chatRunId: string | null;
+    chatSending: boolean;
+    lastError?: string | null;
+    sessionKey: string;
+    basePath: string;
+    hello: GatewayHelloOk | null;
+    chatAvatarUrl: string | null;
+    chatModelOverrides: Record<string, ChatModelOverride | null>;
+    chatModelsLoading: boolean;
+    chatModelCatalog: ModelCatalogEntry[];
+    updateComplete?: Promise<unknown>;
+    refreshSessionsAfterChat: Set<string>;
+    /** Callback for slash-command side effects that need app-level access. */
+    onSlashAction?: (action: string) => void;
+};
+export declare const CHAT_SESSIONS_ACTIVE_MINUTES = 120;
+export declare function isChatBusy(host: ChatHost): boolean;
+export declare function loadChatHistoryForChatPage(host: OpenClawApp, opts?: {
+    preserveLastLatency?: boolean;
+}): Promise<void>;
+export declare function isChatStopCommand(text: string): boolean;
+export declare function handleAbortChat(host: ChatHost): Promise<void>;
+declare function flushChatQueue(host: ChatHost): Promise<void>;
+export declare function removeQueuedMessage(host: ChatHost, id: string): void;
+export declare function handleSendChat(host: ChatHost, messageOverride?: string, opts?: {
+    restoreDraft?: boolean;
+}): Promise<void>;
+export declare function refreshChat(host: ChatHost, opts?: {
+    scheduleScroll?: boolean;
+}): Promise<void>;
+export declare const flushChatQueueForEvent: typeof flushChatQueue;
+export declare function refreshChatAvatar(host: ChatHost): Promise<void>;
+export {};

package/dist/ui/src/ui/app-defaults.d.ts

@@ -0,0 +1,4 @@
+import type { LogLevel } from "./types.ts";
+import type { CronFormState } from "./ui-types.ts";
+export declare const DEFAULT_LOG_LEVEL_FILTERS: Record<LogLevel, boolean>;
+export declare const DEFAULT_CRON_FORM: CronFormState;

package/dist/ui/src/ui/app-events.d.ts

@@ -0,0 +1,5 @@
+export type EventLogEntry = {
+    ts: number;
+    event: string;
+    payload?: unknown;
+};

package/dist/ui/src/ui/app-gateway.d.ts

@@ -0,0 +1,51 @@
+import type { EventLogEntry } from "./app-events.ts";
+import type { ExecApprovalRequest } from "./controllers/exec-approval.ts";
+import { type GatewayEventFrame, type GatewayHelloOk } from "./gateway.ts";
+import { GatewayBrowserClient } from "./gateway.ts";
+import type { Tab } from "./navigation.ts";
+import type { UiSettings } from "./storage.ts";
+import type { AgentsListResult, PresenceEntry, HealthSummary, StatusSummary, UpdateAvailable } from "./types.ts";
+type GatewayHost = {
+    settings: UiSettings;
+    password: string;
+    clientInstanceId: string;
+    userPhone?: string | null;
+    client: GatewayBrowserClient | null;
+    connected: boolean;
+    hello: GatewayHelloOk | null;
+    lastError: string | null;
+    lastErrorCode: string | null;
+    onboarding?: boolean;
+    eventLogBuffer: EventLogEntry[];
+    eventLog: EventLogEntry[];
+    tab: Tab;
+    presenceEntries: PresenceEntry[];
+    presenceError: string | null;
+    presenceStatus: StatusSummary | null;
+    agentsLoading: boolean;
+    agentsList: AgentsListResult | null;
+    agentsError: string | null;
+    healthLoading: boolean;
+    healthResult: HealthSummary | null;
+    healthError: string | null;
+    debugHealth: HealthSummary | null;
+    assistantName: string;
+    assistantAvatar: string | null;
+    assistantAgentId: string | null;
+    serverVersion: string | null;
+    sessionKey: string;
+    chatRunId: string | null;
+    refreshSessionsAfterChat: Set<string>;
+    execApprovalQueue: ExecApprovalRequest[];
+    execApprovalError: string | null;
+    updateAvailable: UpdateAvailable | null;
+};
+export declare function resolveControlUiClientVersion(params: {
+    gatewayUrl: string;
+    serverVersion: string | null;
+    pageUrl?: string;
+}): string | undefined;
+export declare function connectGateway(host: GatewayHost): void;
+export declare function handleGatewayEvent(host: GatewayHost, evt: GatewayEventFrame): void;
+export declare function applySnapshot(host: GatewayHost, hello: GatewayHelloOk): void;
+export {};

package/dist/ui/src/ui/app-lifecycle.d.ts

@@ -0,0 +1,30 @@
+import type { Tab } from "./navigation.ts";
+type LifecycleHost = {
+    basePath: string;
+    client?: {
+        stop: () => void;
+    } | null;
+    connectGeneration: number;
+    connected?: boolean;
+    tab: Tab;
+    assistantName: string;
+    assistantAvatar: string | null;
+    assistantAgentId: string | null;
+    serverVersion: string | null;
+    chatHasAutoScrolled: boolean;
+    chatManualRefreshInFlight: boolean;
+    chatLoading: boolean;
+    chatMessages: unknown[];
+    chatToolMessages: unknown[];
+    chatStream: string | null;
+    logsAutoFollow: boolean;
+    logsAtBottom: boolean;
+    logsEntries: unknown[];
+    popStateHandler: () => void;
+    topbarObserver: ResizeObserver | null;
+};
+export declare function handleConnected(host: LifecycleHost): void;
+export declare function handleFirstUpdated(host: LifecycleHost): void;
+export declare function handleDisconnected(host: LifecycleHost): void;
+export declare function handleUpdated(host: LifecycleHost, changed: Map<PropertyKey, unknown>): void;
+export {};

package/dist/ui/src/ui/app-polling.d.ts

@@ -0,0 +1,16 @@
+type PollingHost = {
+    nodesPollInterval: number | null;
+    logsPollInterval: number | null;
+    debugPollInterval: number | null;
+    payloadLogsPollInterval: number | null;
+    tab: string;
+};
+export declare function startNodesPolling(host: PollingHost): void;
+export declare function stopNodesPolling(host: PollingHost): void;
+export declare function startLogsPolling(host: PollingHost): void;
+export declare function stopLogsPolling(host: PollingHost): void;
+export declare function startDebugPolling(host: PollingHost): void;
+export declare function stopDebugPolling(host: PollingHost): void;
+export declare function startPayloadLogsPolling(host: PollingHost): void;
+export declare function stopPayloadLogsPolling(host: PollingHost): void;
+export {};

package/dist/ui/src/ui/app-render-usage-tab.d.ts

@@ -0,0 +1,3 @@
+import { nothing } from "lit";
+import type { AppViewState } from "./app-view-state.ts";
+export declare function renderUsageTab(state: AppViewState): import("lit").TemplateResult<1> | typeof nothing;

package/dist/ui/src/ui/app-render.d.ts

@@ -0,0 +1,3 @@
+import type { AppViewState } from "./app-view-state.ts";
+import "./components/dashboard-header.ts";
+export declare function renderApp(state: AppViewState): import("lit").TemplateResult<1>;